Generic TCP-option framework and adoption for TCP-SMC and TCP-MD5
Subsystems (6)
v2 cover Generic TCP-option framework and adoption for TCP-SMC and TCP-MD5
Resubmit as v2 RFC to get some feedback before net-next opens up again. Only minor changes (see below).
This patchset introduces a generic framework for handling TCP-options.
TCP-options like TCP_MD5 and SMC are rather rare use-cases, but their implementation is rather intrusive to the TCP-stack. Other, more recent TCP extensions like TCP-crypt, MPTCP or TCP-AO would make this situation even worse.
This new framework allows to add these TCP-options in a modular way. Writing, reading and acting upon these options is done through callbacks that get registered to a TCP-socket. A TCP-socket has a list of "extra" TCP-options that it will use.
We make TCP-SMC and TCP-MD5SIG adopt this new framework. As can be seen, there is now no more TCP-SMC code in the TCP-files and the TCP-MD5 code has been reduced to a bare minimum.
This patchset is admittedly rather big, but we wanted to show where the framework will lead to and what it enables. Suggestions as to how to better structure the patchset is appreciated.
There is still work to be done to more efficiently check for extra TCP options in performance-sensitive code paths. A rate-limited static key would nearly eliminate overhead if no extra TCP options are in use system-wide, or a flag in a likely-hot cache line could work well.
For now we opted for a simple if (unlikely(!hlist_empty(...)) check.
Feedback is very welcome!
Thanks,
Mat & Christoph
Changelog:
===
v1 -> v2:
* Some minor fixes thanks to the buildbot when certain configs are disabled (Patch 5 and 12)
* Add spdx-header in the new files (Patch 11)
* Added Ivan Delande to the CC-list as he did some TCP-MD5 changes in the past.
Christoph Paasch (13):
tcp: Write options after the header has been fully done
tcp: Pass sock and skb to tcp_options_write
tcp: Allow tcp_fast_parse_options to drop segments
tcp_smc: Make smc_parse_options return 1 on success
tcp_smc: Make SMC use TCP extra-option framework
tcp_md5: Don't pass along md5-key
tcp_md5: Detect key inside tcp_v4_send_ack instead of passing it as an
argument
tcp_md5: Detect key inside tcp_v6_send_response instead of passing it
as an argument
tcp_md5: Check for TCP_MD5 after TCP Timestamps in
tcp_established_options
tcp_md5: Move TCP-MD5 code out of TCP itself
tcp_md5: Use tcp_extra_options in output path
tcp_md5: Cleanup TCP-code
tcp_md5: Use TCP extra-options on the input path
Mat Martineau (1):
tcp: Register handlers for extra TCP options
drivers/infiniband/hw/cxgb4/cm.c | 2 +- include/linux/inet_diag.h | 1 + include/linux/tcp.h | 43 +- include/linux/tcp_md5.h | 40 ++ include/net/inet_sock.h | 3 +- include/net/tcp.h | 213 +++--- net/ipv4/Makefile | 1 + net/ipv4/syncookies.c | 6 +- net/ipv4/tcp.c | 391 ++++++++--- net/ipv4/tcp_diag.c | 81 +-- net/ipv4/tcp_input.c | 137 ++-- net/ipv4/tcp_ipv4.c | 556 ++-------------- net/ipv4/tcp_md5.c | 1359 ++++++++++++++++++++++++++++++++++++++ net/ipv4/tcp_minisocks.c | 75 +-- net/ipv4/tcp_output.c | 182 +---- net/ipv6/syncookies.c | 6 +- net/ipv6/tcp_ipv6.c | 390 ++--------- net/smc/af_smc.c | 190 +++++- 18 files changed, 2228 insertions(+), 1448 deletions(-) create mode 100644 include/linux/tcp_md5.h create mode 100644 net/ipv4/tcp_md5.c
Signature · 1 line
2.16.1
RFC v2 1/14 tcp: Write options after the header has been fully done
The generic TCP-option framework will need to have access to the full TCP-header (e.g., if we want to compute a checksum for TCP-MD5).
Thus, we move the call to tcp_options_write() to after all the fields in the header have been filled out.
--- net/ipv4/tcp_output.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
net/ipv4/tcp_output.c +2 -2
@@ -1126,7 +1126,6 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it, } } -tcp_options_write ((__be32 *)(th +1 ), tp, &opts);skb_shinfo (skb)->gso_type = sk->sk_gso_type;if (likely (!(tcb->tcp_flags &TCPHDR_SYN ))) { th->window =htons (tcp_select_window (sk));
@@ -1137,6 +1136,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,*/ th->window =htons (min (tp->rcv_wnd,65535U )); } +tcp_options_write ((__be32 *)(th +1 ), tp, &opts);#ifdef CONFIG_TCP_MD5SIG /* Calculate the MD5 hash, as we have all we need now */ if (md5) {
@@ -3247,8 +3247,8 @@ struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,/* RFC1323: The window in SYN & SYN/ACK segments is never scaled. */ th->window =htons (min (req->rsk_rcv_wnd,65535U )); -tcp_options_write ((__be32 *)(th +1 ),NULL , &opts); th->doff = (tcp_header_size >>2 ); +tcp_options_write ((__be32 *)(th +1 ),NULL , &opts);__TCP_INC_STATS (sock_net (sk),TCP_MIB_OUTSEGS );#ifdef CONFIG_TCP_MD5SIG
Signature · 1 line
2.16.1
RFC v2 2/14 tcp: Pass sock and skb to tcp_options_write
In reply to Christoph PaaschAn upcoming patch adds a configurable, per-socket list of TCP options to populate in the TCP header. This requires tcp_options_write() to know the socket (to use the options list) and the skb (to provide visibility to the packet data for options like TCP_MD5SIG).
--- net/ipv4/tcp_output.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
net/ipv4/tcp_output.c +7 -3
@@ -444,10 +444,14 @@ struct tcp_out_options {* At least SACK_PERM as the first option is known to lead to a disaster * (but it may well be that other scenarios fail similarly). */ -static void tcp_options_write (__be32 *ptr,struct tcp_sock *tp, +static void tcp_options_write (__be32 *ptr,struct sk_buff *skb,struct sock *sk,struct tcp_out_options *opts) {u16 options = opts->options;/* mungable copy */ +struct tcp_sock *tp =NULL ; + +if (sk_fullsock (sk)) + tp =tcp_sk (sk);if (unlikely (OPTION_MD5 & options)) { *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
@@ -1136,7 +1140,7 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,*/ th->window =htons (min (tp->rcv_wnd,65535U )); } -tcp_options_write ((__be32 *)(th +1 ), tp, &opts); +tcp_options_write ((__be32 *)(th +1 ), skb, sk, &opts);#ifdef CONFIG_TCP_MD5SIG /* Calculate the MD5 hash, as we have all we need now */ if (md5) {
@@ -3248,7 +3252,7 @@ struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,/* RFC1323: The window in SYN & SYN/ACK segments is never scaled. */ th->window =htons (min (req->rsk_rcv_wnd,65535U )); th->doff = (tcp_header_size >>2 ); -tcp_options_write ((__be32 *)(th +1 ),NULL , &opts); +tcp_options_write ((__be32 *)(th +1 ), skb,req_to_sk (req), &opts);__TCP_INC_STATS (sock_net (sk),TCP_MIB_OUTSEGS );#ifdef CONFIG_TCP_MD5SIG
Signature · 1 line
2.16.1
David Miller
maintainerRe: [RFC v2 02/14] tcp: Pass sock and skb to tcp_options_write
From: Christoph Paasch <[email protected]>
Date: Wed, 31 Jan 2018 16:07:04 -0800
Quoted 18 lines
An upcoming patch adds a configurable, per-socket list of TCP options to populate in the TCP header. This requires
tcp_options_write()to know the socket (to use the options list) and the skb (to provide visibility to the packet data for options likeTCP_MD5SIG).Signed-off-by Christoph Paasch <[email protected]>Reviewed-by Mat Martineau <[email protected]>--- net/ipv4/tcp_output.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)net/ipv4/tcp_output.c +0
-0@@ -444,10 +444,14 @@ struct tcp_out_options {* At least SACK_PERM as the first option is known to lead to a disaster * (but it may well be that other scenarios fail similarly).
net/ipv4/tcp_output.c struct tcp_out_options { · line 454
Quoted 10 lines
net/ipv4/tcp_output.c +5
-1*/ -static void tcp_options_write (__be32 *ptr,struct tcp_sock *tp, +static void tcp_options_write (__be32 *ptr,struct sk_buff *skb,struct sock *sk,struct tcp_out_options *opts) {u16 options = opts->options;/* mungable copy */ +struct tcp_sock *tp =NULL ; + +if (sk_fullsock (sk)) + tp =tcp_sk (sk);
This adds a new test to the packet header building fast path, and all of the call sites know whether they are dealing with a full sock or not so the test is superfluous.
RFC v2 3/14 tcp: Allow tcp_fast_parse_options to drop segments
In reply to Christoph PaaschAfter parsing the TCP-options, some option-kinds might trigger a drop of the segment (e.g., as is the case for TCP_MD5). As we are moving to consolidate the TCP_MD5-code in follow-up patches, we need to add the capability to drop a segment right after parsing the options in tcp_fast_parse_options().
Originally, tcp_fast_parse_options() returned false, when there is no timestamp option, except in the case of the slow-path processing through tcp_parse_options() where it always returns true.
So, the return-value of tcp_fast_parse_options() was kind of inconsistent. With this patch, we make it return true when the segment should get dropped based on the parsed options, and false otherwise.
In tcp_validate_incoming, we will then just check for tp->rx_opt.saw_tstamp to see if we should verify PAWS.
The goto will be used in a follow-up patch to check whether one of the options triggers a drop of the segment.
--- net/ipv4/tcp_input.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-)
net/ipv4/tcp_input.c +10 -5
@@ -3847,6 +3847,8 @@ static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr/* Fast parse options. This hopes to only see timestamps. * If it is wrong it falls back on tcp_parse_options(). +* +* Returns true if we should drop this packet based on present TCP-options. */ static bool tcp_fast_parse_options(const struct net *net, const struct sk_buff *skb,
@@ -3857,18 +3859,19 @@ static bool tcp_fast_parse_options(const struct net *net,*/ if (th->doff == (sizeof (*th) /4 )) { tp->rx_opt.saw_tstamp =0 ; -return false; + goto extra_opt_check; }else if (tp->rx_opt.tstamp_ok && th->doff == ((sizeof (*th) +TCPOLEN_TSTAMP_ALIGNED ) /4 )) {if (tcp_parse_aligned_timestamp (tp, th)) -return true; + goto extra_opt_check; }tcp_parse_options (net, skb, &tp->rx_opt,1 ,NULL );if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr) tp->rx_opt.rcv_tsecr -= tp->tsoffset; -return true; +extra_opt_check: +return false; }#ifdef CONFIG_TCP_MD5SIG
@@ -5188,9 +5191,11 @@ static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,struct tcp_sock *tp =tcp_sk (sk);bool rst_seq_match = false; +if (tcp_fast_parse_options (sock_net (sk), skb, th, tp)) + goto discard; +/* RFC1323: H1. Apply PAWS check first. */ -if (tcp_fast_parse_options (sock_net (sk), skb, th, tp) && - tp->rx_opt.saw_tstamp && +if (tp->rx_opt.saw_tstamp &&tcp_paws_discard (sk, skb)) {if (!th->rst) {NET_INC_STATS (sock_net (sk),LINUX_MIB_PAWSESTABREJECTED );
Signature · 1 line
2.16.1
RFC v2 4/14 tcp_smc: Make smc_parse_options return 1 on success
In reply to Christoph PaaschAs we allow a generic TCP-option parser that also parses experimental TCP options, we need to add a return-value to smc_parse_options() that indicates whether the option actually matched or not.
--- net/ipv4/tcp_input.c | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-)
net/ipv4/tcp_input.c +8 -5
@@ -3691,19 +3691,22 @@ static void tcp_parse_fastopen_option(int len, const unsigned char *cookie, foc->exp = exp_opt; } -static void smc_parse_options (const struct tcphdr *th, -struct tcp_options_received *opt_rx, -const unsigned char *ptr, -int opsize) +static int smc_parse_options (const struct tcphdr *th, +struct tcp_options_received *opt_rx, +const unsigned char *ptr, +int opsize) {#if IS_ENABLED (CONFIG_SMC )if (static_branch_unlikely (&tcp_have_smc)) {if (th->syn && !(opsize &1 ) && opsize >=TCPOLEN_EXP_SMC_BASE && -get_unaligned_be32 (ptr) ==TCPOPT_SMC_MAGIC ) +get_unaligned_be32 (ptr) ==TCPOPT_SMC_MAGIC ) { opt_rx->smc_ok =1 ; +return 1 ; + } }#endif +return 0 ; }/* Look for tcp options. Normally only called on SYN and SYNACK packets.
Signature · 1 line
2.16.1
RFC v2 5/14 tcp: Register handlers for extra TCP options
In reply to Christoph PaaschFrom: Mat Martineau <[email protected]>
Allow additional TCP options to be handled by registered hook functions.
Registered options have a priority that determines the order in which options are prepared and written. Lower priority numbers are handled first.
Option parsing will call the provided 'parse' function when a TCP option number is not recognized by the normal option parsing code.
After parsing, there are two places where we post-process the options. First, a 'check' callback that allows to drop the packet based on the parsed options (e.g., useful for TCP MD5SIG). Then, a 'post_process' function that gets called after other validity checks (aka, in-window, PAWS,...). This post_process function can then update other state for this particular extra-option.
In the output-path, the 'prepare' function determines the required space for registered options and store associated data. 'write' adds the option to the TCP header.
These additional TCP-options are stored in hlists of the TCP-socket. To pass the state and options around during the 3-way handshake and in time-wait state, the hlists are also on the tcp_request_sock and tcp_timewait_sock.
The list is copied from the listener to the request-socket (calling into the 'copy' callback). Then, moved from the request-socket to the TCP-socket and finally to the time-wait socket.
---
Notes:
v2: * Fix a compiler error in tcp_twsk_destructor when TCP_MD5SIG is disabled
drivers/infiniband/hw/cxgb4/cm.c | 2 +- include/linux/tcp.h | 28 ++++ include/net/tcp.h | 110 ++++++++++++- net/ipv4/syncookies.c | 6 +- net/ipv4/tcp.c | 327 ++++++++++++++++++++++++++++++++++++++- net/ipv4/tcp_input.c | 49 +++++- net/ipv4/tcp_ipv4.c | 98 +++++++++--- net/ipv4/tcp_minisocks.c | 34 +++- net/ipv4/tcp_output.c | 40 ++--- net/ipv6/syncookies.c | 6 +- net/ipv6/tcp_ipv6.c | 32 ++++ 11 files changed, 677 insertions(+), 55 deletions(-)
drivers/infiniband/hw/cxgb4/cm.c +1 -1
@@ -3746,7 +3746,7 @@ static void build_cpl_pass_accept_req(struct sk_buff *skb, int stid , u8 tos)*/ memset (&tmp_opt,0 ,sizeof (tmp_opt));tcp_clear_options (&tmp_opt); -tcp_parse_options (&init_net, skb, &tmp_opt,0 ,NULL ); +tcp_parse_options (&init_net, skb, &tmp_opt,0 ,NULL ,NULL ); req =__skb_push (skb,sizeof (*req));memset (req,0 ,sizeof (*req));
include/linux/tcp.h +28 -0
@@ -115,6 +115,24 @@ static inline void tcp_clear_options(struct tcp_options_received *rx_opt)#endif } +#define OPTION_SACK_ADVERTISE (1 << 0) +#define OPTION_TS (1 << 1) +#define OPTION_MD5 (1 << 2) +#define OPTION_WSCALE (1 << 3) +#define OPTION_FAST_OPEN_COOKIE (1 << 8) +#define OPTION_SMC (1 << 9) + +struct tcp_out_options { +u16 options;/* bit field of OPTION_* */ +u16 mss;/* 0 to disable */ +u8 ws;/* window scale, 0 to disable */ +u8 num_sack_blocks;/* number of SACK blocks to include */ +u8 hash_size;/* bytes in hash_location */ +__u8 *hash_location;/* temporary pointer, overloaded */ +__u32 tsval, tsecr;/* need to include OPTION_TS */ +struct tcp_fastopen_cookie *fastopen_cookie;/* Fast open cookie */ +}; +/* This is the max number of SACKS that we'll generate and process. It's safe * to increase this, although since: * size = TCPOLEN_SACK_BASE_ALIGNED (4) + n * TCPOLEN_SACK_PERBLOCK (8)
@@ -137,6 +155,7 @@ struct tcp_request_sock {* FastOpen it's the seq# * after data-in-SYN. */ +struct hlist_head tcp_option_list; };static inline struct tcp_request_sock *tcp_rsk (const struct request_sock *req)
@@ -384,6 +403,8 @@ struct tcp_sock {*/ struct request_sock *fastopen_rsk;u32 *saved_syn; + +struct hlist_head tcp_option_list; };enum tsq_enum {
@@ -411,6 +432,11 @@ static inline struct tcp_sock *tcp_sk(const struct sock *sk)return (struct tcp_sock *)sk; } +static inline struct sock *tcp_to_sk (const struct tcp_sock *tp) +{ +return (struct sock *)tp; +} +struct tcp_timewait_sock {struct inet_timewait_sock tw_sk;#define tw_rcv_nxt tw_sk.__tw_common.skc_tw_rcv_nxt
@@ -423,6 +449,8 @@ struct tcp_timewait_sock {u32 tw_last_oow_ack_time;long tw_ts_recent_stamp; + +struct hlist_head tcp_option_list;#ifdef CONFIG_TCP_MD5SIG struct tcp_md5sig_key *tw_md5_key;#endif
include/net/tcp.h +109 -1
126 lines not on this page · raw message
net/ipv4/syncookies.c +5 -1
@@ -313,7 +313,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)/* check for timestamp cookie support */ memset (&tcp_opt,0 ,sizeof (tcp_opt)); -tcp_parse_options (sock_net (sk), skb, &tcp_opt,0 ,NULL ); +tcp_parse_options (sock_net (sk), skb, &tcp_opt,0 ,NULL , sk);if (tcp_opt.saw_tstamp && tcp_opt.rcv_tsecr) { tsoff = secure_tcp_ts_off(sock_net(sk),
@@ -325,6 +325,10 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb)if (!cookie_timestamp_decode (sock_net (sk), &tcp_opt)) goto out; +if (unlikely (!hlist_empty (&tp->tcp_option_list)) && +tcp_extopt_check (sk, skb, &tcp_opt)) + goto out; + ret =NULL ; req =inet_reqsk_alloc (&tcp_request_sock_ops, sk, false);/* for safety */ if (!req)
net/ipv4/tcp.c +326 -1
345 lines not on this page · raw message
net/ipv4/tcp_input.c +41 -8
121 lines not on this page · raw message
net/ipv4/tcp_ipv4.c +80 -18
181 lines not on this page · raw message
net/ipv4/tcp_minisocks.c +28 -6
@@ -95,9 +95,10 @@ tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb,struct tcp_timewait_sock *tcptw =tcp_twsk ((struct sock *)tw);bool paws_reject = false; - tmp_opt.saw_tstamp =0 ; +tcp_clear_options (&tmp_opt);if (th->doff > (sizeof (*th) >>2 ) && tcptw->tw_ts_recent_stamp) { -tcp_parse_options (twsk_net (tw), skb, &tmp_opt,0 ,NULL ); +tcp_parse_options (twsk_net (tw), skb, &tmp_opt,0 ,NULL , + (struct sock *)tw);if (tmp_opt.saw_tstamp) {if (tmp_opt.rcv_tsecr)
@@ -108,6 +109,10 @@ tcp_timewait_state_process(struct inet_timewait_sock *tw, struct sk_buff *skb, } } +if (unlikely (!hlist_empty (&tcptw->tcp_option_list)) && +tcp_extopt_check ((struct sock *)tw, skb, &tmp_opt)) +return TCP_TW_SUCCESS ; +if (tw->tw_substate ==TCP_FIN_WAIT2 ) {/* Just repeat all the checks of tcp_rcv_state_process() */
@@ -251,7 +256,7 @@ EXPORT_SYMBOL(tcp_timewait_state_process);void tcp_time_wait (struct sock *sk,int state,int timeo) {const struct inet_connection_sock *icsk =inet_csk (sk); -const struct tcp_sock *tp =tcp_sk (sk); +struct tcp_sock *tp =tcp_sk (sk);struct inet_timewait_sock *tw;struct inet_timewait_death_row *tcp_death_row = &sock_net (sk)->ipv4.tcp_death_row;
@@ -271,6 +276,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo) tcptw->tw_ts_recent_stamp = tp->rx_opt.ts_recent_stamp; tcptw->tw_ts_offset = tp->tsoffset; tcptw->tw_last_oow_ack_time =0 ; +INIT_HLIST_HEAD (&tcptw->tcp_option_list);#if IS_ENABLED (CONFIG_IPV6 )if (tw->tw_family ==PF_INET6 ) {
@@ -284,6 +290,10 @@ void tcp_time_wait(struct sock *sk, int state, int timeo) }#endif +if (unlikely (!hlist_empty (&tp->tcp_option_list))) { +tcp_extopt_move (sk, (struct sock *)tw); +INIT_HLIST_HEAD (&tp->tcp_option_list); + }#ifdef CONFIG_TCP_MD5SIG /* * The timewait bucket does not have the key DB from the
@@ -335,12 +345,15 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)void tcp_twsk_destructor (struct sock *sk) { -#ifdef CONFIG_TCP_MD5SIG struct tcp_timewait_sock *twsk =tcp_twsk (sk); +#ifdef CONFIG_TCP_MD5SIG if (twsk->tw_md5_key)kfree_rcu (twsk->tw_md5_key, rcu);#endif + +if (unlikely (!hlist_empty (&twsk->tcp_option_list))) +tcp_extopt_destroy (sk); }EXPORT_SYMBOL_GPL (tcp_twsk_destructor);
@@ -470,6 +483,7 @@ struct sock *tcp_create_openreq_child(const struct sock *sk,INIT_LIST_HEAD (&newtp->tsq_node);INIT_LIST_HEAD (&newtp->tsorted_sent_queue); +INIT_HLIST_HEAD (&newtp->tcp_option_list);tcp_init_wl (newtp, treq->rcv_isn);
@@ -545,6 +559,9 @@ struct sock *tcp_create_openreq_child(const struct sock *sk,if (newtp->af_specific->md5_lookup (sk, newsk)) newtp->tcp_header_len +=TCPOLEN_MD5SIG_ALIGNED ;#endif +if (unlikely (!hlist_empty (&treq->tcp_option_list))) + newtp->tcp_header_len +=tcp_extopt_add_header (req_to_sk (req), newsk); +if (skb->len >=TCP_MSS_DEFAULT + newtp->tcp_header_len) newicsk->icsk_ack.last_seg_size = skb->len - newtp->tcp_header_len; newtp->rx_opt.mss_clamp = req->mss;
@@ -587,9 +604,10 @@ struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,bool paws_reject = false;bool own_req; - tmp_opt.saw_tstamp =0 ; +tcp_clear_options (&tmp_opt);if (th->doff > (sizeof (struct tcphdr )>>2 )) { -tcp_parse_options (sock_net (sk), skb, &tmp_opt,0 ,NULL ); +tcp_parse_options (sock_net (sk), skb, &tmp_opt,0 ,NULL , +req_to_sk (req));if (tmp_opt.saw_tstamp) { tmp_opt.ts_recent = req->ts_recent;
@@ -604,6 +622,10 @@ struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, } } +if (unlikely (!hlist_empty (&tcp_rsk (req)->tcp_option_list)) && +tcp_extopt_check (req_to_sk (req), skb, &tmp_opt)) +return NULL ; +/* Check for pure retransmitted SYN. */ if (TCP_SKB_CB(skb)->seq == tcp_rsk(req)->rcv_isn && flg == TCP_FLAG_SYN &&
net/ipv4/tcp_output.c +22 -18
@@ -398,13 +398,6 @@ static inline bool tcp_urg_mode(const struct tcp_sock *tp)return tp->snd_una != tp->snd_up; } -#define OPTION_SACK_ADVERTISE (1 << 0) -#define OPTION_TS (1 << 1) -#define OPTION_MD5 (1 << 2) -#define OPTION_WSCALE (1 << 3) -#define OPTION_FAST_OPEN_COOKIE (1 << 8) -#define OPTION_SMC (1 << 9) -static void smc_options_write (__be32 *ptr,u16 *options) {#if IS_ENABLED (CONFIG_SMC )
@@ -420,17 +413,6 @@ static void smc_options_write(__be32 *ptr, u16 *options)#endif } -struct tcp_out_options { -u16 options;/* bit field of OPTION_* */ -u16 mss;/* 0 to disable */ -u8 ws;/* window scale, 0 to disable */ -u8 num_sack_blocks;/* number of SACK blocks to include */ -u8 hash_size;/* bytes in hash_location */ -__u8 *hash_location;/* temporary pointer, overloaded */ -__u32 tsval, tsecr;/* need to include OPTION_TS */ -struct tcp_fastopen_cookie *fastopen_cookie;/* Fast open cookie */ -}; -/* Write previously computed TCP options to the packet. * * Beware: Something in the Internet is very sensitive to the ordering of
@@ -447,12 +429,15 @@ struct tcp_out_options {static void tcp_options_write (__be32 *ptr,struct sk_buff *skb,struct sock *sk,struct tcp_out_options *opts) { +struct hlist_head *extopt_list;u16 options = opts->options;/* mungable copy */ struct tcp_sock *tp =NULL ;if (sk_fullsock (sk)) tp =tcp_sk (sk); + extopt_list =tcp_extopt_get_list (sk); +if (unlikely (OPTION_MD5 & options)) { *ptr++ =htonl ((TCPOPT_NOP <<24 ) | (TCPOPT_NOP <<16 ) | (TCPOPT_MD5SIG <<8 ) |TCPOLEN_MD5SIG );
@@ -543,6 +528,9 @@ static void tcp_options_write(__be32 *ptr, struct sk_buff *skb, struct sock *sk, }smc_options_write (ptr, &options); + +if (unlikely (!hlist_empty (extopt_list))) +tcp_extopt_write (ptr, skb, opts, sk); } static void smc_set_option(const struct tcp_sock *tp,
@@ -645,6 +633,10 @@ static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,smc_set_option (tp, opts, &remaining); +if (unlikely (!hlist_empty (&tp->tcp_option_list))) + remaining -=tcp_extopt_prepare (skb,TCPHDR_SYN , remaining, + opts,tcp_to_sk (tp)); +return MAX_TCP_OPTION_SPACE - remaining; }
@@ -708,6 +700,11 @@ static unsigned int tcp_synack_options(const struct sock *sk,smc_set_option_cond (tcp_sk (sk), ireq, opts, &remaining); +if (unlikely (!hlist_empty (&tcp_rsk (req)->tcp_option_list))) + remaining -=tcp_extopt_prepare (skb,TCPHDR_SYN |TCPHDR_ACK , + remaining, opts, +req_to_sk (req)); +return MAX_TCP_OPTION_SPACE - remaining; }
@@ -741,6 +738,10 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb size +=TCPOLEN_TSTAMP_ALIGNED ; } +if (unlikely (!hlist_empty (&tp->tcp_option_list))) + size +=tcp_extopt_prepare (skb,0 ,MAX_TCP_OPTION_SPACE - size, + opts,tcp_to_sk (tp)); + eff_sacks = tp->rx_opt.num_sacks + tp->rx_opt.dsack;if (unlikely (eff_sacks)) {const unsigned int remaining =MAX_TCP_OPTION_SPACE - size;
@@ -3308,6 +3309,9 @@ static void tcp_connect_init(struct sock *sk) tp->tcp_header_len +=TCPOLEN_MD5SIG_ALIGNED ;#endif +if (unlikely (!hlist_empty (&tp->tcp_option_list))) + tp->tcp_header_len +=tcp_extopt_add_header (sk, sk); +/* If user gave his TCP_MAXSEG, record it to clamp */ if (tp->rx_opt.user_mss) tp->rx_opt.mss_clamp = tp->rx_opt.user_mss;
net/ipv6/syncookies.c +5 -1
@@ -162,7 +162,7 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)/* check for timestamp cookie support */ memset (&tcp_opt,0 ,sizeof (tcp_opt)); -tcp_parse_options (sock_net (sk), skb, &tcp_opt,0 ,NULL ); +tcp_parse_options (sock_net (sk), skb, &tcp_opt,0 ,NULL , sk);if (tcp_opt.saw_tstamp && tcp_opt.rcv_tsecr) { tsoff = secure_tcpv6_ts_off(sock_net(sk),
@@ -174,6 +174,10 @@ struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb)if (!cookie_timestamp_decode (sock_net (sk), &tcp_opt)) goto out; +if (unlikely (!hlist_empty (&tp->tcp_option_list)) && +tcp_extopt_check (sk, skb, &tcp_opt)) + goto out; + ret =NULL ; req =inet_reqsk_alloc (&tcp6_request_sock_ops, sk, false);if (!req)
net/ipv6/tcp_ipv6.c +32 -0
@@ -499,6 +499,9 @@ static int tcp_v6_send_synack(const struct sock *sk, struct dst_entry *dst,static void tcp_v6_reqsk_destructor (struct request_sock *req) { +if (unlikely (!hlist_empty (&tcp_rsk (req)->tcp_option_list))) +tcp_extopt_destroy (req_to_sk (req)); +kfree (inet_rsk (req)->ipv6_opt);kfree_skb (inet_rsk (req)->pktopts); }
@@ -788,6 +791,8 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32unsigned int tot_len =sizeof (struct tcphdr );struct dst_entry *dst;__be32 *topt; +struct hlist_head *extopt_list =NULL ; +struct tcp_out_options extraopts;if (tsecr) tot_len +=TCPOLEN_TSTAMP_ALIGNED ;
@@ -796,6 +801,25 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 tot_len +=TCPOLEN_MD5SIG_ALIGNED ;#endif +if (sk) + extopt_list =tcp_extopt_get_list (sk); + +if (unlikely (extopt_list && !hlist_empty (extopt_list))) { +unsigned int remaining =MAX_TCP_OPTION_SPACE - tot_len; +u8 extraflags = rst ?TCPHDR_RST :0 ; +int used; + +if (!rst || !th->ack) + extraflags |=TCPHDR_ACK ; + +memset (&extraopts,0 ,sizeof (extraopts)); + + used =tcp_extopt_response_prepare (skb, extraflags, remaining, + &extraopts, sk); + + tot_len += used; + } + buff =alloc_skb (MAX_HEADER +sizeof (struct ipv6hdr ) + tot_len,GFP_ATOMIC );if (!buff)
@@ -836,6 +860,9 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 }#endif +if (unlikely (extopt_list && !hlist_empty (extopt_list))) +tcp_extopt_response_write (topt, skb, t1, &extraopts, sk); +memset (&fl6,0 ,sizeof (fl6)); fl6.daddr =ipv6_hdr (skb)->saddr; fl6.saddr =ipv6_hdr (skb)->daddr;
@@ -1230,6 +1257,11 @@ static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *skb_set_owner_r (newnp->pktoptions, newsk); } } + +if (unlikely (!hlist_empty (&tcp_rsk (req)->tcp_option_list))) { +tcp_extopt_move (req_to_sk (req), newsk); +INIT_HLIST_HEAD (&tcp_rsk (req)->tcp_option_list); + } }return newsk;
Signature · 1 line
2.16.1
RFC v2 6/14 tcp_smc: Make SMC use TCP extra-option framework
In reply to Christoph PaaschAdopt the extra-option framework for SMC.
It allows us to entirely remove SMC-code out of the TCP-stack.
The static key is gone, as this is now covered by the static key of the extra-option framework.
We allocate state (struct tcp_smc_opt) that indicates whether SMC was successfully negotiated or not and check this state in the relevant functions.
--- include/linux/tcp.h | 3 +- include/net/inet_sock.h | 3 +- include/net/tcp.h | 4 - net/ipv4/tcp.c | 5 -- net/ipv4/tcp_input.c | 36 --------- net/ipv4/tcp_minisocks.c | 18 ----- net/ipv4/tcp_output.c | 54 -------------- net/smc/af_smc.c | 190 +++++++++++++++++++++++++++++++++++++++++++++-- 8 files changed, 186 insertions(+), 127 deletions(-)
include/linux/tcp.h +1 -2
@@ -257,8 +257,7 @@ struct tcp_sock { syn_fastopen_ch:1, /* Active TFO re-enabling probe */ syn_data_acked:1,/* data in SYN is acked by SYN-ACK */ save_syn:1, /* Save headers of SYN packet */ - is_cwnd_limited:1,/* forward progress limited by snd_cwnd? */ - syn_smc:1; /* SYN includes SMC */ + is_cwnd_limited:1;/* forward progress limited by snd_cwnd? */u32 tlp_high_seq;/* snd_nxt at the time of TLP retransmit. */ /* RTT measurement */
include/net/inet_sock.h +1 -2
@@ -90,8 +90,7 @@ struct inet_request_sock { wscale_ok : 1, ecn_ok : 1, acked : 1, - no_srccheck: 1, - smc_ok : 1; + no_srccheck: 1;u32 ir_mark;union {struct ip_options_rcu __rcu *ireq_opt;
include/net/tcp.h +0 -4
@@ -2093,10 +2093,6 @@ static inline bool tcp_bpf_ca_needs_ecn(struct sock *sk)return (tcp_call_bpf (sk,BPF_SOCK_OPS_NEEDS_ECN ,0 ,NULL ) ==1 ); } -#if IS_ENABLED (CONFIG_SMC ) -extern struct static_key_false tcp_have_smc; -#endif -struct tcp_extopt_store ;struct tcp_extopt_ops {
net/ipv4/tcp.c +0 -5
@@ -292,11 +292,6 @@ EXPORT_SYMBOL(sysctl_tcp_mem);atomic_long_t tcp_memory_allocated;/* Current allocated memory. */ EXPORT_SYMBOL (tcp_memory_allocated); -#if IS_ENABLED (CONFIG_SMC ) -DEFINE_STATIC_KEY_FALSE (tcp_have_smc); -EXPORT_SYMBOL (tcp_have_smc); -#endif -/* * Current number of TCP sockets. */
net/ipv4/tcp_input.c +0 -36
@@ -3691,24 +3691,6 @@ static void tcp_parse_fastopen_option(int len, const unsigned char *cookie, foc->exp = exp_opt; } -static int smc_parse_options (const struct tcphdr *th, -struct tcp_options_received *opt_rx, -const unsigned char *ptr, -int opsize) -{ -#if IS_ENABLED (CONFIG_SMC ) -if (static_branch_unlikely (&tcp_have_smc)) { -if (th->syn && !(opsize &1 ) && - opsize >=TCPOLEN_EXP_SMC_BASE && -get_unaligned_be32 (ptr) ==TCPOPT_SMC_MAGIC ) { - opt_rx->smc_ok =1 ; -return 1 ; - } - } -#endif -return 0 ; -} -/* Look for tcp options. Normally only called on SYN and SYNACK packets. * But, this can also be called on packets in the established flow when * the fast version below fails.
@@ -3816,9 +3798,6 @@ void tcp_parse_options(const struct net *net,tcp_parse_fastopen_option (opsize -TCPOLEN_EXP_FASTOPEN_BASE , ptr +2 , th->syn, foc, true); - else if (smc_parse_options(th, opt_rx, ptr, - opsize)) - break; else if (opsize >= TCPOLEN_EXP_BASE) tcp_extopt_parse(get_unaligned_be32(ptr), opsize, ptr, skb,
@@ -5595,16 +5574,6 @@ static bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack,return false; } -static void smc_check_reset_syn (struct tcp_sock *tp) -{ -#if IS_ENABLED (CONFIG_SMC ) -if (static_branch_unlikely (&tcp_have_smc)) { -if (tp->syn_smc && !tp->rx_opt.smc_ok) - tp->syn_smc =0 ; - } -#endif -} -static int tcp_rcv_synsent_state_process (struct sock *sk,struct sk_buff *skb,const struct tcphdr *th) {
@@ -5715,8 +5684,6 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,* is initialized. */ tp->copied_seq = tp->rcv_nxt; -smc_check_reset_syn (tp); -smp_mb ();tcp_finish_connect (sk, skb);
@@ -6173,9 +6140,6 @@ static void tcp_openreq_init(struct request_sock *req, ireq->ir_rmt_port =tcp_hdr (skb)->source; ireq->ir_num =ntohs (tcp_hdr (skb)->dest); ireq->ir_mark =inet_request_mark (sk, skb); -#if IS_ENABLED (CONFIG_SMC ) - ireq->smc_ok = rx_opt->smc_ok; -#endif } struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
net/ipv4/tcp_minisocks.c +0 -18
@@ -435,21 +435,6 @@ void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst) }EXPORT_SYMBOL_GPL (tcp_ca_openreq_child); -static void smc_check_reset_syn_req (struct tcp_sock *oldtp, -struct request_sock *req, -struct tcp_sock *newtp) -{ -#if IS_ENABLED (CONFIG_SMC ) -struct inet_request_sock *ireq; - -if (static_branch_unlikely (&tcp_have_smc)) { - ireq =inet_rsk (req); -if (oldtp->syn_smc && !ireq->smc_ok) - newtp->syn_smc =0 ; - } -#endif -} -/* This is not only more efficient than what we used to do, it eliminates * a lot of code duplication between IPv4/IPv6 SYN recv processing. -DaveM *
@@ -467,9 +452,6 @@ struct sock *tcp_create_openreq_child(const struct sock *sk,struct tcp_request_sock *treq =tcp_rsk (req);struct inet_connection_sock *newicsk =inet_csk (newsk);struct tcp_sock *newtp =tcp_sk (newsk); -struct tcp_sock *oldtp =tcp_sk (sk); - -smc_check_reset_syn_req (oldtp, req, newtp);/* Now setup tcp_sock */ newtp->pred_flags =0 ;
net/ipv4/tcp_output.c +0 -54
82 lines not on this page · raw message
net/smc/af_smc.c +184 -6
280 lines not on this page · raw message
Signature · 1 line
2.16.1
RFC v2 7/14 tcp_md5: Don't pass along md5-key
In reply to Christoph PaaschIt is much cleaner to store the key-pointer in tcp_out_options. It allows to remove some MD5-specific code out of the function-arguments and paves the way to adopting the TCP-option framework with TCP-MD5.
--- include/linux/tcp.h | 1 + net/ipv4/tcp_output.c | 46 +++++++++++++++++++--------------------------- 2 files changed, 20 insertions(+), 27 deletions(-)
include/linux/tcp.h +1 -0
@@ -131,6 +131,7 @@ struct tcp_out_options {__u8 *hash_location;/* temporary pointer, overloaded */ __u32 tsval, tsecr;/* need to include OPTION_TS */ struct tcp_fastopen_cookie *fastopen_cookie;/* Fast open cookie */ +struct tcp_md5sig_key *md5;/* TCP_MD5 signature key */ };/* This is the max number of SACKS that we'll generate and process. It's safe
net/ipv4/tcp_output.c +19 -27
149 lines not on this page · raw message
Signature · 1 line
2.16.1
RFC v2 8/14 tcp_md5: Detect key inside tcp_v4_send_ack instead of passing it as an argument
In reply to Christoph PaaschThis will simplify to consolidate the TCP_MD5-code into a single place.
--- net/ipv4/tcp_ipv4.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)
net/ipv4/tcp_ipv4.c +14 -4
@@ -764,7 +764,6 @@ static void tcp_v4_send_reset(const struct sock *sk, struct sk_buff *skb)static void tcp_v4_send_ack (const struct sock *sk,struct sk_buff *skb,u32 seq,u32 ack,u32 win,u32 tsval,u32 tsecr,int oif, -struct tcp_md5sig_key *key,int reply_flags,u8 tos) {const struct tcphdr *th =tcp_hdr (skb);
@@ -773,6 +772,9 @@ static void tcp_v4_send_ack(const struct sock *sk,__be32 opt[(MAX_TCP_OPTION_SPACE >>2 )]; } rep;struct hlist_head *extopt_list =NULL ; +#ifdef CONFIG_TCP_MD5SIG +struct tcp_md5sig_key *key; +#endif struct net *net =sock_net (sk);struct ip_reply_arg arg;int offset =0 ;
@@ -803,6 +805,17 @@ static void tcp_v4_send_ack(const struct sock *sk, rep.th.ack =1 ; rep.th.window =htons (win); +#ifdef CONFIG_TCP_MD5SIG +if (sk->sk_state ==TCP_TIME_WAIT ) { + key =tcp_twsk_md5_key (tcp_twsk (sk)); + }else if (sk->sk_state ==TCP_NEW_SYN_RECV ) { + key =tcp_md5_do_lookup (sk, (union tcp_md5_addr *)&ip_hdr (skb)->saddr, +AF_INET ); + }else { + key =NULL ;/* Should not happen */ + } +#endif +if (unlikely (extopt_list && !hlist_empty (extopt_list))) {unsigned int remaining;struct tcp_out_options opts;
@@ -872,7 +885,6 @@ static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)tcp_time_stamp_raw () + tcptw->tw_ts_offset, tcptw->tw_ts_recent, tw->tw_bound_dev_if, -tcp_twsk_md5_key (tcptw), tw->tw_transparent ?IP_REPLY_ARG_NOSRCCHECK :0 , tw->tw_tos );
@@ -900,8 +912,6 @@ static void tcp_v4_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb,tcp_time_stamp_raw () +tcp_rsk (req)->ts_off, req->ts_recent,0 , -tcp_md5_do_lookup (sk, (union tcp_md5_addr *)&ip_hdr (skb)->saddr, -AF_INET ),inet_rsk (req)->no_srccheck ?IP_REPLY_ARG_NOSRCCHECK :0 , ip_hdr(skb)->tos); }
Signature · 1 line
2.16.1
RFC v2 9/14 tcp_md5: Detect key inside tcp_v6_send_response instead of passing it as an argument
In reply to Christoph PaaschWe want to move all the TCP-MD5 code to a single place which enables us to factor the TCP-MD5 code out of the TCP-stack into the extra-option framework.
Detection of whether or not to drop the segment (as done in tcp_v6_send_reset()) has now been moved to tcp_v6_send_response(). So we needed to adapt the latter so that it can handle the case where we want to exit without sending anything.
--- net/ipv6/tcp_ipv6.c | 119 +++++++++++++++++++++++++--------------------------- 1 file changed, 57 insertions(+), 62 deletions(-)
net/ipv6/tcp_ipv6.c +57 -62
@@ -82,12 +82,6 @@ static const struct inet_connection_sock_af_ops ipv6_specific;#ifdef CONFIG_TCP_MD5SIG static const struct tcp_sock_af_ops tcp_sock_ipv6_specific;static const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific; -#else -static struct tcp_md5sig_key *tcp_v6_md5_do_lookup (const struct sock *sk, -const struct in6_addr *addr) -{ -return NULL ; -}#endif static void inet6_sk_rx_dst_set (struct sock *sk,const struct sk_buff *skb)
@@ -779,12 +773,11 @@ static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = {static void tcp_v6_send_response (const struct sock *sk,struct sk_buff *skb,u32 seq,u32 ack,u32 win,u32 tsval,u32 tsecr, -int oif,struct tcp_md5sig_key *key,int rst, -u8 tclass,__be32 label) +int oif,int rst,u8 tclass,__be32 label) {const struct tcphdr *th =tcp_hdr (skb);struct tcphdr *t1; -struct sk_buff *buff; +struct sk_buff *buff =NULL ;struct flowi6 fl6;struct net *net = sk ?sock_net (sk) :dev_net (skb_dst (skb)->dev);struct sock *ctl_sk = net->ipv6.tcp_sk;
@@ -793,10 +786,54 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32__be32 *topt;struct hlist_head *extopt_list =NULL ;struct tcp_out_options extraopts; +#ifdef CONFIG_TCP_MD5SIG +struct tcp_md5sig_key *key =NULL ; +const __u8 *hash_location =NULL ; +struct ipv6hdr *ipv6h =ipv6_hdr (skb); +#endif if (tsecr) tot_len +=TCPOLEN_TSTAMP_ALIGNED ;#ifdef CONFIG_TCP_MD5SIG +rcu_read_lock (); + hash_location =tcp_parse_md5sig_option (th); +if (sk &&sk_fullsock (sk)) { + key =tcp_v6_md5_do_lookup (sk, &ipv6h->saddr); + }else if (sk && sk->sk_state ==TCP_TIME_WAIT ) { +struct tcp_timewait_sock *tcptw =tcp_twsk (sk); + + key =tcp_twsk_md5_key (tcptw); + }else if (sk && sk->sk_state ==TCP_NEW_SYN_RECV ) { + key =tcp_v6_md5_do_lookup (sk, &ipv6h->saddr); + }else if (hash_location) { +unsigned char newhash[16 ]; +struct sock *sk1 =NULL ; +int genhash; + +/* active side is lost. Try to find listening socket through +* source port, and then find md5 key through listening socket. +* we are not loose security here: +* Incoming packet is checked with md5 hash with finding key, +* no RST generated if md5 hash doesn't match. +*/ + sk1 =inet6_lookup_listener (dev_net (skb_dst (skb)->dev), + &tcp_hashinfo,NULL ,0 , + &ipv6h->saddr, + th->source, &ipv6h->daddr, +ntohs (th->source),tcp_v6_iif (skb), +tcp_v6_sdif (skb)); +if (!sk1) + goto out; + + key =tcp_v6_md5_do_lookup (sk1, &ipv6h->saddr); +if (!key) + goto out; + + genhash =tcp_v6_md5_hash_skb (newhash, key,NULL , skb); +if (genhash ||memcmp (hash_location, newhash,16 ) !=0 ) + goto out; + } +if (key) tot_len +=TCPOLEN_MD5SIG_ALIGNED ;#endif
@@ -823,7 +860,7 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 buff =alloc_skb (MAX_HEADER +sizeof (struct ipv6hdr ) + tot_len,GFP_ATOMIC );if (!buff) -return ; + goto out;skb_reserve (buff,MAX_HEADER +sizeof (struct ipv6hdr ) + tot_len);
@@ -900,24 +937,21 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32TCP_INC_STATS (net,TCP_MIB_OUTSEGS );if (rst)TCP_INC_STATS (net,TCP_MIB_OUTRSTS ); -return ; + buff =NULL ; } +out:kfree_skb (buff); + +#ifdef CONFIG_TCP_MD5SIG +rcu_read_unlock (); +#endif }static void tcp_v6_send_reset (const struct sock *sk,struct sk_buff *skb) {const struct tcphdr *th =tcp_hdr (skb);u32 seq =0 , ack_seq =0 ; -struct tcp_md5sig_key *key =NULL ; -#ifdef CONFIG_TCP_MD5SIG -const __u8 *hash_location =NULL ; -struct ipv6hdr *ipv6h =ipv6_hdr (skb); -unsigned char newhash[16 ]; -int genhash; -struct sock *sk1 =NULL ; -#endif int oif =0 ;if (th->rst)
@@ -929,38 +963,6 @@ static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb)if (!sk && !ipv6_unicast_destination (skb))return ; -#ifdef CONFIG_TCP_MD5SIG -rcu_read_lock (); - hash_location =tcp_parse_md5sig_option (th); -if (sk &&sk_fullsock (sk)) { - key =tcp_v6_md5_do_lookup (sk, &ipv6h->saddr); - }else if (hash_location) { -/* -* active side is lost. Try to find listening socket through -* source port, and then find md5 key through listening socket. -* we are not loose security here: -* Incoming packet is checked with md5 hash with finding key, -* no RST generated if md5 hash doesn't match. -*/ - sk1 =inet6_lookup_listener (dev_net (skb_dst (skb)->dev), - &tcp_hashinfo,NULL ,0 , - &ipv6h->saddr, - th->source, &ipv6h->daddr, -ntohs (th->source),tcp_v6_iif (skb), -tcp_v6_sdif (skb)); -if (!sk1) - goto out; - - key =tcp_v6_md5_do_lookup (sk1, &ipv6h->saddr); -if (!key) - goto out; - - genhash =tcp_v6_md5_hash_skb (newhash, key,NULL , skb); -if (genhash ||memcmp (hash_location, newhash,16 ) !=0 ) - goto out; - } -#endif -if (th->ack) seq =ntohl (th->ack_seq);else
@@ -972,20 +974,14 @@ static void tcp_v6_send_reset(const struct sock *sk, struct sk_buff *skb)trace_tcp_send_reset (sk, skb); } -tcp_v6_send_response (sk, skb, seq, ack_seq,0 ,0 ,0 , oif, key,1 ,0 ,0 ); - -#ifdef CONFIG_TCP_MD5SIG -out: -rcu_read_unlock (); -#endif +tcp_v6_send_response (sk, skb, seq, ack_seq,0 ,0 ,0 , oif,1 ,0 ,0 ); }static void tcp_v6_send_ack (const struct sock *sk,struct sk_buff *skb,u32 seq,u32 ack,u32 win,u32 tsval,u32 tsecr,int oif, -struct tcp_md5sig_key *key,u8 tclass, -__be32 label) +u8 tclass,__be32 label) { -tcp_v6_send_response (sk, skb, seq, ack, win, tsval, tsecr, oif, key,0 , +tcp_v6_send_response (sk, skb, seq, ack, win, tsval, tsecr, oif,0 , tclass, label); }
@@ -997,7 +993,7 @@ static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)tcp_v6_send_ack (sk, skb, tcptw->tw_snd_nxt, tcptw->tw_rcv_nxt, tcptw->tw_rcv_wnd >> tw->tw_rcv_wscale,tcp_time_stamp_raw () + tcptw->tw_ts_offset, - tcptw->tw_ts_recent, tw->tw_bound_dev_if,tcp_twsk_md5_key (tcptw), + tcptw->tw_ts_recent, tw->tw_bound_dev_if, tw->tw_tclass,cpu_to_be32 (tw->tw_flowlabel));inet_twsk_put (tw);
@@ -1020,7 +1016,6 @@ static void tcp_v6_reqsk_send_ack(const struct sock *sk, struct sk_buff *skb, req->rsk_rcv_wnd >>inet_rsk (req)->rcv_wscale,tcp_time_stamp_raw () +tcp_rsk (req)->ts_off, req->ts_recent, sk->sk_bound_dev_if, -tcp_v6_md5_do_lookup (sk, &ipv6_hdr (skb)->saddr), 0, 0); }
Signature · 1 line
2.16.1
RFC v2 10/14 tcp_md5: Check for TCP_MD5 after TCP Timestamps in tcp_established_options
In reply to Christoph PaaschIt really does not matter, because we never use TCP timestamps when TCP_MD5 is enabled (see tcp_syn_options).
Moving TCP_MD5 a bit lower allows for easier adoption of the tcp_extra_option framework.
--- net/ipv4/tcp_output.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
net/ipv4/tcp_output.c +7 -7
@@ -662,6 +662,13 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb opts->options =0 ; +if (likely (tp->rx_opt.tstamp_ok)) { + opts->options |=OPTION_TS ; + opts->tsval = skb ?tcp_skb_timestamp (skb) + tp->tsoffset :0 ; + opts->tsecr = tp->rx_opt.ts_recent; + size +=TCPOLEN_TSTAMP_ALIGNED ; + } +#ifdef CONFIG_TCP_MD5SIG opts->md5 = tp->af_specific->md5_lookup (sk, sk);if (unlikely (opts->md5)) {
@@ -672,13 +679,6 @@ static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb opts->md5 =NULL ;#endif -if (likely (tp->rx_opt.tstamp_ok)) { - opts->options |=OPTION_TS ; - opts->tsval = skb ?tcp_skb_timestamp (skb) + tp->tsoffset :0 ; - opts->tsecr = tp->rx_opt.ts_recent; - size +=TCPOLEN_TSTAMP_ALIGNED ; - } -if (unlikely (!hlist_empty (&tp->tcp_option_list))) size +=tcp_extopt_prepare (skb,0 ,MAX_TCP_OPTION_SPACE - size, opts,tcp_to_sk (tp));
Signature · 1 line
2.16.1
RFC v2 11/14 tcp_md5: Move TCP-MD5 code out of TCP itself
In reply to Christoph PaaschThis is all just copy-pasting the TCP_MD5-code into functions that are placed in net/ipv4/tcp_md5.c.
---
Notes:
v2: * Add SPDX-identifier (Mat Martineau's feedback)
include/linux/inet_diag.h | 1 + include/linux/tcp_md5.h | 137 ++++++ include/net/tcp.h | 77 ---- net/ipv4/Makefile | 1 + net/ipv4/tcp.c | 133 +----- net/ipv4/tcp_diag.c | 81 +--- net/ipv4/tcp_input.c | 38 -- net/ipv4/tcp_ipv4.c | 520 ++------------------- net/ipv4/tcp_md5.c | 1103 +++++++++++++++++++++++++++++++++++++++++++++ net/ipv4/tcp_minisocks.c | 23 +- net/ipv4/tcp_output.c | 4 +- net/ipv6/tcp_ipv6.c | 318 +------------ 12 files changed, 1304 insertions(+), 1132 deletions(-) create mode 100644 include/linux/tcp_md5.h create mode 100644 net/ipv4/tcp_md5.c
include/linux/inet_diag.h +1 -0
@@ -2,6 +2,7 @@#ifndef _INET_DIAG_H_#define _INET_DIAG_H_ 1 +#include <linux/user_namespace.h> #include <uapi/linux/inet_diag.h> struct net ;
include/linux/tcp_md5.h new file +137 -0
137 lines not on this page · raw message
include/net/tcp.h +0 -77
95 lines not on this page · raw message
net/ipv4/Makefile +1 -0
@@ -60,6 +60,7 @@ obj-$(CONFIG_TCP_CONG_LP) += tcp_lp.o obj-$(CONFIG_TCP_CONG_YEAH) += tcp_yeah.o obj-$(CONFIG_TCP_CONG_ILLINOIS) += tcp_illinois.o obj-$(CONFIG_NETLABEL) += cipso_ipv4.o +obj-$(CONFIG_TCP_MD5SIG) += tcp_md5.o obj-$(CONFIG_XFRM) += xfrm4_policy.o xfrm4_state.o xfrm4_input.o \ xfrm4_output.o xfrm4_protocol.o
net/ipv4/tcp.c +1 -132
145 lines not on this page · raw message
net/ipv4/tcp_diag.c +6 -75
103 lines not on this page · raw message
net/ipv4/tcp_input.c +0 -38
@@ -3867,44 +3867,6 @@ static bool tcp_fast_parse_options(const struct net *net,return false; } -#ifdef CONFIG_TCP_MD5SIG -/* -* Parse MD5 Signature option -*/ -const u8 *tcp_parse_md5sig_option (const struct tcphdr *th) -{ -int length = (th->doff <<2 ) -sizeof (*th); -const u8 *ptr = (const u8 *)(th +1 ); - -/* If the TCP option is too short, we can short cut */ -if (length <TCPOLEN_MD5SIG ) -return NULL ; - -while (length >0 ) { -int opcode = *ptr++; -int opsize; - -switch (opcode) { -case TCPOPT_EOL : -return NULL ; -case TCPOPT_NOP : - length--; -continue ; -default : - opsize = *ptr++; -if (opsize <2 || opsize > length) -return NULL ; -if (opcode ==TCPOPT_MD5SIG ) -return opsize ==TCPOLEN_MD5SIG ? ptr :NULL ; - } - ptr += opsize -2 ; - length -= opsize; - } -return NULL ; -} -EXPORT_SYMBOL (tcp_parse_md5sig_option); -#endif -/* Sorry, PAWS as specified is broken wrt. pure-ACKs -DaveM * * It is not fatal. If this ACK does _not_ change critical state (seqs, window)
net/ipv4/tcp_ipv4.c +34 -486
647 lines not on this page · raw message
net/ipv4/tcp_md5.c new file +1103 -0
1,103 lines not on this page · raw message
net/ipv4/tcp_minisocks.c +4 -19
@@ -22,6 +22,7 @@#include <linux/module.h> #include <linux/slab.h> #include <linux/sysctl.h> +#include <linux/tcp_md5.h> #include <linux/workqueue.h> #include <linux/static_key.h> #include <net/tcp.h>
@@ -295,21 +296,7 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)INIT_HLIST_HEAD (&tp->tcp_option_list); }#ifdef CONFIG_TCP_MD5SIG -/* -* The timewait bucket does not have the key DB from the -* sock structure. We just make a quick copy of the -* md5 key being used (if indeed we are using one) -* so the timewait ack generating code has the key. -*/ -do { -struct tcp_md5sig_key *key; - tcptw->tw_md5_key =NULL ; - key = tp->af_specific->md5_lookup (sk, sk); -if (key) { - tcptw->tw_md5_key =kmemdup (key,sizeof (*key),GFP_ATOMIC ); -BUG_ON (tcptw->tw_md5_key && !tcp_alloc_md5sig_pool ()); - } - }while (0 ); +tcp_md5_time_wait (sk, tw);#endif /* Get the TIME_WAIT timeout firing. */
@@ -348,8 +335,7 @@ void tcp_twsk_destructor(struct sock *sk)struct tcp_timewait_sock *twsk =tcp_twsk (sk);#ifdef CONFIG_TCP_MD5SIG -if (twsk->tw_md5_key) -kfree_rcu (twsk->tw_md5_key, rcu); +tcp_md5_twsk_destructor (twsk);#endif if (unlikely (!hlist_empty (&twsk->tcp_option_list)))
@@ -538,8 +524,7 @@ struct sock *tcp_create_openreq_child(const struct sock *sk, newtp->tsoffset = treq->ts_off;#ifdef CONFIG_TCP_MD5SIG newtp->md5sig_info =NULL ;/*XXX*/ -if (newtp->af_specific->md5_lookup (sk, newsk)) - newtp->tcp_header_len +=TCPOLEN_MD5SIG_ALIGNED ; +tcp_md5_add_header_len (sk, newsk);#endif if (unlikely (!hlist_empty (&treq->tcp_option_list))) newtp->tcp_header_len +=tcp_extopt_add_header (req_to_sk (req), newsk);
net/ipv4/tcp_output.c +2 -2
@@ -42,6 +42,7 @@#include <linux/gfp.h> #include <linux/module.h> #include <linux/static_key.h> +#include <linux/tcp_md5.h> #include <trace/events/tcp.h>
@@ -3243,8 +3244,7 @@ static void tcp_connect_init(struct sock *sk) tp->tcp_header_len +=TCPOLEN_TSTAMP_ALIGNED ;#ifdef CONFIG_TCP_MD5SIG -if (tp->af_specific->md5_lookup (sk, sk)) - tp->tcp_header_len +=TCPOLEN_MD5SIG_ALIGNED ; +tcp_md5_add_header_len (sk, sk);#endif if (unlikely (!hlist_empty (&tp->tcp_option_list)))
net/ipv6/tcp_ipv6.c +15 -303
391 lines not on this page · raw message
Signature · 1 line
2.16.1
RFC v2 12/14 tcp_md5: Use tcp_extra_options in output path
In reply to Christoph PaaschThis patch starts making use of the extra_option framework for TCP_MD5.
One tricky part is that extra_options are called at the end of the tcp_syn_options(), while TCP_MD5 is called at the beginning.
TCP_MD5 is called at the beginning because it wants to disable TCP-timestamps (for option-space reasons). So, in the _prepare-function of the extra options we need to undo the work that was done when enabling TCP timestamps.
Another thing to note is that in tcp_v4_send_reset (and its IPv6 counterpart), we were looking previously for the listening-socket (if sk == NULL) in case there was an MD5 signature in the TCP-option space of the incoming packet.
With the extra-option framework we can't do this anymore, because extra-options are part of the TCP-socket's tcp_option_list. If there is no socket, it means we can't parse the option.
This shouldn't have an impact, because when we receive a segment and there is not established socket, we will match on the listening socket (if it's still there). Then, when we decide to respond with a RST in tcp_rcv_state_process, we will give to tcp_v4_send_reset() the listening-socket and thus will parse the TCP_MD5 option.
---
Notes:
v2: * Fix compiler warning about unused variable when RCU-debugging is disabled
include/linux/tcp.h | 10 +- include/linux/tcp_md5.h | 62 ----- net/ipv4/tcp_ipv4.c | 55 ---- net/ipv4/tcp_md5.c | 695 +++++++++++++++++++++++++++++++++-------------- net/ipv4/tcp_minisocks.c | 12 - net/ipv4/tcp_output.c | 68 +---- net/ipv6/tcp_ipv6.c | 23 -- 7 files changed, 487 insertions(+), 438 deletions(-)
include/linux/tcp.h +2 -8
@@ -127,11 +127,11 @@ struct tcp_out_options {u16 mss;/* 0 to disable */ u8 ws;/* window scale, 0 to disable */ u8 num_sack_blocks;/* number of SACK blocks to include */ -u8 hash_size;/* bytes in hash_location */ -__u8 *hash_location;/* temporary pointer, overloaded */ __u32 tsval, tsecr;/* need to include OPTION_TS */ struct tcp_fastopen_cookie *fastopen_cookie;/* Fast open cookie */ +#ifdef CONFIG_TCP_MD5SIG struct tcp_md5sig_key *md5;/* TCP_MD5 signature key */ +#endif };/* This is the max number of SACKS that we'll generate and process. It's safe
@@ -391,9 +391,6 @@ struct tcp_sock {#ifdef CONFIG_TCP_MD5SIG /* TCP AF-Specific parts; only used by MD5 Signature support so far */ const struct tcp_sock_af_ops *af_specific; - -/* TCP MD5 Signature Option information */ -struct tcp_md5sig_info __rcu *md5sig_info;#endif /* TCP fastopen related information */
@@ -451,9 +448,6 @@ struct tcp_timewait_sock {long tw_ts_recent_stamp;struct hlist_head tcp_option_list; -#ifdef CONFIG_TCP_MD5SIG -struct tcp_md5sig_key *tw_md5_key; -#endif };static inline struct tcp_timewait_sock *tcp_twsk (const struct sock *sk)
include/linux/tcp_md5.h +0 -62
83 lines not on this page · raw message
net/ipv4/tcp_ipv4.c +0 -55
114 lines not on this page · raw message
net/ipv4/tcp_md5.c +484 -211
862 lines not on this page · raw message
net/ipv4/tcp_minisocks.c +0 -12
@@ -22,7 +22,6 @@#include <linux/module.h> #include <linux/slab.h> #include <linux/sysctl.h> -#include <linux/tcp_md5.h> #include <linux/workqueue.h> #include <linux/static_key.h> #include <net/tcp.h>
@@ -295,9 +294,6 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)tcp_extopt_move (sk, (struct sock *)tw);INIT_HLIST_HEAD (&tp->tcp_option_list); } -#ifdef CONFIG_TCP_MD5SIG -tcp_md5_time_wait (sk, tw); -#endif /* Get the TIME_WAIT timeout firing. */ if (timeo < rto)
@@ -334,10 +330,6 @@ void tcp_twsk_destructor(struct sock *sk) {struct tcp_timewait_sock *twsk =tcp_twsk (sk); -#ifdef CONFIG_TCP_MD5SIG -tcp_md5_twsk_destructor (twsk); -#endif -if (unlikely (!hlist_empty (&twsk->tcp_option_list)))tcp_extopt_destroy (sk); }
@@ -522,10 +514,6 @@ struct sock *tcp_create_openreq_child(const struct sock *sk, newtp->tcp_header_len =sizeof (struct tcphdr ); } newtp->tsoffset = treq->ts_off; -#ifdef CONFIG_TCP_MD5SIG - newtp->md5sig_info =NULL ;/*XXX*/ -tcp_md5_add_header_len (sk, newsk); -#endif if (unlikely (!hlist_empty (&treq->tcp_option_list))) newtp->tcp_header_len +=tcp_extopt_add_header (req_to_sk (req), newsk);
net/ipv4/tcp_output.c +1 -67
128 lines not on this page · raw message
net/ipv6/tcp_ipv6.c +0 -23
@@ -576,20 +576,6 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32if (tsecr) tot_len +=TCPOLEN_TSTAMP_ALIGNED ; -#ifdef CONFIG_TCP_MD5SIG -{ -int ret; - - ret =tcp_v6_md5_send_response_prepare (skb,0 , -MAX_TCP_OPTION_SPACE - tot_len, - &extraopts, sk); - -if (ret ==-1 ) - goto out; - - tot_len += ret; -} -#endif if (sk) extopt_list =tcp_extopt_get_list (sk);
@@ -638,11 +624,6 @@ static void tcp_v6_send_response(const struct sock *sk, struct sk_buff *skb, u32 *topt++ =htonl (tsecr); } -#ifdef CONFIG_TCP_MD5SIG -if (extraopts.md5) -tcp_v6_md5_send_response_write (topt, skb, t1, &extraopts, sk); -#endif -if (unlikely (extopt_list && !hlist_empty (extopt_list)))tcp_extopt_response_write (topt, skb, t1, &extraopts, sk);
@@ -956,10 +937,6 @@ static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff * newinet->inet_daddr = newinet->inet_saddr =LOOPBACK4_IPV6 ; newinet->inet_rcv_saddr =LOOPBACK4_IPV6 ; -#ifdef CONFIG_TCP_MD5SIG -tcp_v6_md5_syn_recv_sock (sk, newsk); -#endif -if (__inet_inherit_port (sk, newsk) <0 ) {inet_csk_prepare_forced_close (newsk);tcp_done (newsk);
Signature · 1 line
2.16.1
RFC v2 13/14 tcp_md5: Cleanup TCP-code
In reply to Christoph PaaschNow that we have consolidated the TCP_MD5 output path, we can cleanup TCP and its callbacks to MD5.
These callbacks are solely there to handle the different address-familiese (v4, v6 and v4mapped).
Now that we have isolated the TCP_MD5-code it is acceptable to add a bit more complexity inside tcp_md5.c to handle these address-families at the benefit of getting rid of these callbacks in tcp_sock, together with its assignments in tcp_v4/6_connect,...
--- include/linux/tcp.h | 5 - include/linux/tcp_md5.h | 18 +-- include/net/tcp.h | 24 ---- net/ipv4/tcp.c | 2 +- net/ipv4/tcp_ipv4.c | 8 -- net/ipv4/tcp_md5.c | 340 ++++++++++++++++++++++-------------------------- net/ipv6/tcp_ipv6.c | 17 --- 7 files changed, 155 insertions(+), 259 deletions(-)
include/linux/tcp.h +0 -5
@@ -388,11 +388,6 @@ struct tcp_sock {* while socket was owned by user. */ -#ifdef CONFIG_TCP_MD5SIG -/* TCP AF-Specific parts; only used by MD5 Signature support so far */ -const struct tcp_sock_af_ops *af_specific; -#endif -/* TCP fastopen related information */ struct tcp_fastopen_request *fastopen_req;/* fastopen_rsk points to request_sock that resulted in this big
include/linux/tcp_md5.h +2 -16
@@ -27,28 +27,14 @@ struct tcp_md5sig_key {struct rcu_head rcu; }; -extern const struct tcp_sock_af_ops tcp_sock_ipv4_specific; -extern const struct tcp_sock_af_ops tcp_sock_ipv6_specific; -extern const struct tcp_sock_af_ops tcp_sock_ipv6_mapped_specific; -/* - functions */ -int tcp_v4_md5_hash_skb (char *md5_hash,const struct tcp_md5sig_key *key, -const struct sock *sk,const struct sk_buff *skb); -struct tcp_md5sig_key *tcp_v4_md5_lookup (const struct sock *sk, -const struct sock *addr_sk); +int tcp_md5_parse_keys (struct sock *sk,int optname,char __user *optval, +int optlen);bool tcp_v4_inbound_md5_hash (const struct sock *sk,const struct sk_buff *skb); -struct tcp_md5sig_key *tcp_v6_md5_lookup (const struct sock *sk, -const struct sock *addr_sk); - -int tcp_v6_md5_hash_skb (char *md5_hash, -const struct tcp_md5sig_key *key, -const struct sock *sk, -const struct sk_buff *skb); -bool tcp_v6_inbound_md5_hash (const struct sock *sk,const struct sk_buff *skb);
include/net/tcp.h +0 -24
@@ -1730,32 +1730,8 @@ int tcp_conn_request(struct request_sock_ops *rsk_ops,const struct tcp_request_sock_ops *af_ops, struct sock *sk, struct sk_buff *skb); -/* TCP af-specific functions */ -struct tcp_sock_af_ops { -#ifdef CONFIG_TCP_MD5SIG -struct tcp_md5sig_key *(*md5_lookup) (const struct sock *sk, -const struct sock *addr_sk); -int (*calc_md5_hash)(char *location, -const struct tcp_md5sig_key *md5, -const struct sock *sk, -const struct sk_buff *skb); -int (*md5_parse)(struct sock *sk, -int optname, -char __user *optval, -int optlen); -#endif -}; -struct tcp_request_sock_ops {u16 mss_clamp; -#ifdef CONFIG_TCP_MD5SIG -struct tcp_md5sig_key *(*req_md5_lookup)(const struct sock *sk, -const struct sock *addr_sk); -int (*calc_md5_hash) (char *location, -const struct tcp_md5sig_key *md5, -const struct sock *sk, -const struct sk_buff *skb); -#endif void (*init_req)(struct request_sock *req,const struct sock *sk_listener,struct sk_buff *skb);
net/ipv4/tcp.c +1 -1
@@ -2828,7 +2828,7 @@ static int do_tcp_setsockopt(struct sock *sk, int level,case TCP_MD5SIG :case TCP_MD5SIG_EXT :/* Read the IP->Key mappings from userspace */ - err = tp->af_specific->md5_parse (sk, optname, optval, optlen); + err =tcp_md5_parse_keys (sk, optname, optval, optlen);break ;#endif case TCP_USER_TIMEOUT :
net/ipv4/tcp_ipv4.c +0 -8
@@ -889,10 +889,6 @@ struct request_sock_ops tcp_request_sock_ops __read_mostly = {static const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops = { .mss_clamp =TCP_MSS_DEFAULT , -#ifdef CONFIG_TCP_MD5SIG - .req_md5_lookup = tcp_v4_md5_lookup, - .calc_md5_hash = tcp_v4_md5_hash_skb, -#endif .init_req = tcp_v4_init_req, #ifdef CONFIG_SYN_COOKIES .cookie_init_seq = cookie_v4_init_sequence,
@@ -1450,10 +1446,6 @@ static int tcp_v4_init_sock(struct sock *sk) icsk->icsk_af_ops = &ipv4_specific; -#ifdef CONFIG_TCP_MD5SIG -tcp_sk (sk)->af_specific = &tcp_sock_ipv4_specific; -#endif -return 0 ; }
net/ipv4/tcp_md5.c +152 -188
422 lines not on this page · raw message
net/ipv6/tcp_ipv6.c +0 -17
@@ -207,9 +207,6 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, icsk->icsk_af_ops = &ipv6_mapped; sk->sk_backlog_rcv = tcp_v4_do_rcv; -#ifdef CONFIG_TCP_MD5SIG - tp->af_specific = &tcp_sock_ipv6_mapped_specific; -#endif err =tcp_v4_connect (sk, (struct sockaddr *)&sin,sizeof (sin));
@@ -217,9 +214,6 @@ static int tcp_v6_connect(struct sock *sk, struct sockaddr *uaddr, icsk->icsk_ext_hdr_len = exthdrlen; icsk->icsk_af_ops = &ipv6_specific; sk->sk_backlog_rcv = tcp_v6_do_rcv; -#ifdef CONFIG_TCP_MD5SIG - tp->af_specific = &tcp_sock_ipv6_specific; -#endif goto failure; } np->saddr = sk->sk_v6_rcv_saddr;
@@ -542,10 +536,6 @@ struct request_sock_ops tcp6_request_sock_ops __read_mostly = {static const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops = { .mss_clamp =IPV6_MIN_MTU -sizeof (struct tcphdr ) -sizeof (struct ipv6hdr ), -#ifdef CONFIG_TCP_MD5SIG - .req_md5_lookup = tcp_v6_md5_lookup, - .calc_md5_hash = tcp_v6_md5_hash_skb, -#endif .init_req = tcp_v6_init_req, #ifdef CONFIG_SYN_COOKIES .cookie_init_seq = cookie_v6_init_sequence,
@@ -820,9 +810,6 @@ static struct sock *tcp_v6_syn_recv_sock(const struct sock *sk, struct sk_buff *inet_csk (newsk)->icsk_af_ops = &ipv6_mapped; newsk->sk_backlog_rcv = tcp_v4_do_rcv; -#ifdef CONFIG_TCP_MD5SIG - newtp->af_specific = &tcp_sock_ipv6_mapped_specific; -#endif newnp->ipv6_mc_list =NULL ; newnp->ipv6_ac_list =NULL ;
@@ -1429,10 +1416,6 @@ static int tcp_v6_init_sock(struct sock *sk) icsk->icsk_af_ops = &ipv6_specific; -#ifdef CONFIG_TCP_MD5SIG -tcp_sk (sk)->af_specific = &tcp_sock_ipv6_specific; -#endif -return 0 ; }
Signature · 1 line
2.16.1
RFC v2 14/14 tcp_md5: Use TCP extra-options on the input path
In reply to Christoph PaaschThe checks are now being done through the extra-option framework. For TCP MD5 this means that the check happens a bit later than usual.
--- include/linux/tcp_md5.h | 23 +---------------------- net/ipv4/tcp_input.c | 8 -------- net/ipv4/tcp_ipv4.c | 9 --------- net/ipv4/tcp_md5.c | 29 ++++++++++++++++++++++++----- net/ipv6/tcp_ipv6.c | 9 --------- 5 files changed, 25 insertions(+), 53 deletions(-)
include/linux/tcp_md5.h +1 -22
@@ -32,30 +32,9 @@ struct tcp_md5sig_key {int tcp_md5_parse_keys (struct sock *sk,int optname,char __user *optval,int optlen); -bool tcp_v4_inbound_md5_hash (const struct sock *sk, -const struct sk_buff *skb); - -bool tcp_v6_inbound_md5_hash (const struct sock *sk, -const struct sk_buff *skb); -int tcp_md5_diag_get_aux (struct sock *sk,bool net_admin,struct sk_buff *skb);int tcp_md5_diag_get_aux_size (struct sock *sk,bool net_admin); -#else - -static inline bool tcp_v4_inbound_md5_hash (const struct sock *sk, -const struct sk_buff *skb) -{ -return false; -} - -static inline bool tcp_v6_inbound_md5_hash (const struct sock *sk, -const struct sk_buff *skb) -{ -return false; -} - -#endif - +#endif /* CONFIG_TCP_MD5SIG */ #endif /* _LINUX_TCP_MD5_H */
net/ipv4/tcp_input.c +0 -8
@@ -3774,14 +3774,6 @@ void tcp_parse_options(const struct net *net,TCP_SKB_CB (skb)->sacked = (ptr -2 ) - (unsigned char *)th; }break ; -#ifdef CONFIG_TCP_MD5SIG -case TCPOPT_MD5SIG : -/* -* The MD5 Hash has already been -* checked (see tcp_v{4,6}_do_rcv()). -*/ -break ; -#endif case TCPOPT_FASTOPEN : tcp_parse_fastopen_option( opsize - TCPOLEN_FASTOPEN_BASE,
net/ipv4/tcp_ipv4.c +0 -9
@@ -62,7 +62,6 @@#include <linux/init.h> #include <linux/times.h> #include <linux/slab.h> -#include <linux/tcp_md5.h> #include <net/net_namespace.h> #include <net/icmp.h>
@@ -1249,11 +1248,6 @@ int tcp_v4_rcv(struct sk_buff *skb)struct sock *nsk; sk = req->rsk_listener; -if (unlikely (tcp_v4_inbound_md5_hash (sk, skb))) { -sk_drops_add (sk, skb); -reqsk_put (req); - goto discard_it; - }if (unlikely (sk->sk_state !=TCP_LISTEN )) {inet_csk_reqsk_queue_drop_and_put (sk, req); goto lookup;
@@ -1293,9 +1287,6 @@ int tcp_v4_rcv(struct sk_buff *skb)if (!xfrm4_policy_check (sk,XFRM_POLICY_IN , skb)) goto discard_and_relse; -if (tcp_v4_inbound_md5_hash (sk, skb)) - goto discard_and_relse; -nf_reset (skb);if (tcp_filter (sk, skb))
net/ipv4/tcp_md5.c +24 -5
@@ -30,6 +30,10 @@ static DEFINE_PER_CPU(struct tcp_md5sig_pool, tcp_md5sig_pool);static DEFINE_MUTEX (tcp_md5sig_mutex);static bool tcp_md5sig_pool_populated; +static bool tcp_inbound_md5_hash (struct sock *sk,const struct sk_buff *skb, +struct tcp_options_received *opt_rx, +struct tcp_extopt_store *store); + static unsigned int tcp_md5_extopt_prepare(struct sk_buff *skb, u8 flags, unsigned int remaining, struct tcp_out_options *opts,
@@ -77,6 +81,7 @@ struct tcp_md5_extopt {static const struct tcp_extopt_ops tcp_md5_extra_ops = { .option_kind =TCPOPT_MD5SIG , + .check = tcp_inbound_md5_hash, .prepare = tcp_md5_extopt_prepare, .write = tcp_md5_extopt_write, .response_prepare = tcp_md5_send_response_prepare,
@@ -863,8 +868,8 @@ static struct tcp_md5sig_key *tcp_v4_md5_lookup(const struct sock *sk, }/* Called with rcu_read_lock() */ -bool tcp_v4_inbound_md5_hash (const struct sock *sk, -const struct sk_buff *skb) +static bool tcp_v4_inbound_md5_hash (const struct sock *sk, +const struct sk_buff *skb) {/* This gets called for each TCP segment that arrives * so we want to be efficient.
@@ -918,8 +923,8 @@ bool tcp_v4_inbound_md5_hash(const struct sock *sk, }#if IS_ENABLED (CONFIG_IPV6 ) -bool tcp_v6_inbound_md5_hash (const struct sock *sk, -const struct sk_buff *skb) +static bool tcp_v6_inbound_md5_hash (const struct sock *sk, +const struct sk_buff *skb) {const __u8 *hash_location =NULL ;struct tcp_md5sig_key *hash_expected;
@@ -961,7 +966,6 @@ bool tcp_v6_inbound_md5_hash(const struct sock *sk,return false; } -EXPORT_SYMBOL_GPL (tcp_v6_inbound_md5_hash);static struct tcp_md5sig_key *tcp_v6_md5_lookup (const struct sock *sk,const struct sock *addr_sk)
@@ -971,6 +975,21 @@ static struct tcp_md5sig_key *tcp_v6_md5_lookup(const struct sock *sk,EXPORT_SYMBOL_GPL (tcp_v6_md5_lookup);#endif +static bool tcp_inbound_md5_hash (struct sock *sk,const struct sk_buff *skb, +struct tcp_options_received *opt_rx, +struct tcp_extopt_store *store) +{ +if (skb->protocol ==htons (ETH_P_IP )) { +return tcp_v4_inbound_md5_hash (sk, skb); +#if IS_ENABLED (CONFIG_IPV6 ) + } else { +return tcp_v6_inbound_md5_hash (sk, skb); +#endif + } + +return false; +} +static void tcp_diag_md5sig_fill (struct tcp_diag_md5sig *info,const struct tcp_md5sig_key *key) {
net/ipv6/tcp_ipv6.c +0 -9
@@ -43,7 +43,6 @@#include <linux/ipv6.h> #include <linux/icmpv6.h> #include <linux/random.h> -#include <linux/tcp_md5.h> #include <net/tcp.h> #include <net/ndisc.h>
@@ -1172,11 +1171,6 @@ static int tcp_v6_rcv(struct sk_buff *skb)struct sock *nsk; sk = req->rsk_listener; -if (tcp_v6_inbound_md5_hash (sk, skb)) { -sk_drops_add (sk, skb); -reqsk_put (req); - goto discard_it; - }if (unlikely (sk->sk_state !=TCP_LISTEN )) {inet_csk_reqsk_queue_drop_and_put (sk, req); goto lookup;
@@ -1213,9 +1207,6 @@ static int tcp_v6_rcv(struct sk_buff *skb)if (!xfrm6_policy_check (sk,XFRM_POLICY_IN , skb)) goto discard_and_relse; -if (tcp_v6_inbound_md5_hash (sk, skb)) - goto discard_and_relse; -if (tcp_filter (sk, skb)) goto discard_and_relse; th = (const struct tcphdr *)skb->data;
Signature · 1 line
2.16.1
David Miller
maintainerFrom: Christoph Paasch <[email protected]>
Date: Wed, 31 Jan 2018 16:07:02 -0800
Quoted 4 lines
TCP-options like
TCP_MD5and SMC are rather rare use-cases, but their implementation is rather intrusive to the TCP-stack. Other, more recent TCP extensions like TCP-crypt, MPTCP or TCP-AO would make this situation even worse.
Yet, this current implementation is what allows us to optimize things properly.
And now we're going to do indirect calls to callbacks instead of inline tests as well?
Also, requiring such direct surgery for new TCP options forces the developer to consider the consequences of what the new TCP option does and how it effect both the slow and the fast path.
With abstraction layers, people tend to turn their brains off when it comes to these issues.
Sorry, I'm really not thrilled about this.
I would rather see the new TCP option features be proposed using the existing code and then see how it all can be abstracted away after they are all added.
I can already see in your patches that new overhead is added, new tests in the packet building fast paths that are completely unnecessary with the existing code, etc.
Hello,
Quoted 8 lines · David Miller
From: Christoph Paasch <[email protected]>
Date: Wed, 31 Jan 2018 16:07:02 -0800Quoted 4 lines
TCP-options like
TCP_MD5and SMC are rather rare use-cases, but their implementation is rather intrusive to the TCP-stack. Other, more recent TCP extensions like TCP-crypt, MPTCP or TCP-AO would make this situation even worse.
Quoted 5 lines
Yet, this current implementation is what allows us to optimize things properly.
And now we're going to do indirect calls to callbacks instead of inline tests as well?
Wrt to the potential performance impact, we have considered using static keys that would only be enabled if one socket is using an option that is part of the framework. That way the framework shouldn't cause any performance issues as long as nobody uses these less common options.
Would that be an option to alleviate such concerns?
Or is your concern here that we are impacting the performance of TCP-MD5?
If it's the latter, we indeed are intentionally trading performance of TCP-MD5 for a general "cleaner" TCP-stack (one that has no if-statements for seldom used TCP-options like SMC and MD5). We thought the gain was worth the cost, which can be arguable of course.
Quoted 8 lines
Also, requiring such direct surgery for new TCP options forces the developer to consider the consequences of what the new TCP option does and how it effect both the slow and the fast path.
With abstraction layers, people tend to turn their brains off when it comes to these issues.
Sorry, I'm really not thrilled about this.
I can see your point and the risk that the abstraction layer brings, but let me try to clarify what we think the framework would enable:
Our goal with the framework is to optimize/design for the common-case while still allowing extensibility and less common features.
That way we can keep the TCP-stack clean with the most-used TCP-options (SACK, Timestamps,...), while still allowing the more exotic features like MD5. And only sockets that enable TCP-MD5 will pay the potential performance price for it.
And for new options, the framework forces people to think about how to make the feature work without spreading if-statements across the stack.
If the new option becomes the common-case after some time, it can always be fully integrated into the stack at that moment.
Quoted 3 lines
I would rather see the new TCP option features be proposed using the existing code and then see how it all can be abstracted away after they are all added.
Would a possible path forward be that we rather post the patches that cleanup the TCP-MD5 code.
(meaning roughly patches 7 to 14 but without the option-framework adoption)
That way, we cleanup the TCP-stack at least by factoring out TCP-MD5.
Quoted 3 lines
I can already see in your patches that new overhead is added, new tests in the packet building fast paths that are completely unnecessary with the existing code, etc.
Point taken, we will double-check our impact on the fast-path and make sure to change that.
Thanks for your feedback!
Christoph