1 /* 2 * Syncookies implementation for the Linux kernel 3 * 4 * Copyright (C) 1997 Andi Kleen 5 * Based on ideas by D.J.Bernstein and Eric Schenk. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 */ 12 13 #include <linux/tcp.h> 14 #include <linux/slab.h> 15 #include <linux/random.h> 16 #include <linux/cryptohash.h> 17 #include <linux/kernel.h> 18 #include <linux/export.h> 19 #include <net/tcp.h> 20 #include <net/route.h> 21 22 /* Timestamps: lowest bits store TCP options */ 23 #define TSBITS 6 24 #define TSMASK (((__u32)1 << TSBITS) - 1) 25 26 extern int sysctl_tcp_syncookies; 27 28 static u32 syncookie_secret[2][16-4+SHA_DIGEST_WORDS] __read_mostly; 29 30 #define COOKIEBITS 24 /* Upper bits store count */ 31 #define COOKIEMASK (((__u32)1 << COOKIEBITS) - 1) 32 33 static DEFINE_PER_CPU(__u32 [16 + 5 + SHA_WORKSPACE_WORDS], 34 ipv4_cookie_scratch); 35 36 static u32 cookie_hash(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport, 37 u32 count, int c) 38 { 39 __u32 *tmp; 40 41 net_get_random_once(syncookie_secret, sizeof(syncookie_secret)); 42 43 tmp = this_cpu_ptr(ipv4_cookie_scratch); 44 memcpy(tmp + 4, syncookie_secret[c], sizeof(syncookie_secret[c])); 45 tmp[0] = (__force u32)saddr; 46 tmp[1] = (__force u32)daddr; 47 tmp[2] = ((__force u32)sport << 16) + (__force u32)dport; 48 tmp[3] = count; 49 sha_transform(tmp + 16, (__u8 *)tmp, tmp + 16 + 5); 50 51 return tmp[17]; 52 } 53 54 55 /* 56 * when syncookies are in effect and tcp timestamps are enabled we encode 57 * tcp options in the lower bits of the timestamp value that will be 58 * sent in the syn-ack. 59 * Since subsequent timestamps use the normal tcp_time_stamp value, we 60 * must make sure that the resulting initial timestamp is <= tcp_time_stamp. 61 */ 62 __u32 cookie_init_timestamp(struct request_sock *req) 63 { 64 struct inet_request_sock *ireq; 65 u32 ts, ts_now = tcp_time_stamp; 66 u32 options = 0; 67 68 ireq = inet_rsk(req); 69 70 options = ireq->wscale_ok ? ireq->snd_wscale : 0xf; 71 options |= ireq->sack_ok << 4; 72 options |= ireq->ecn_ok << 5; 73 74 ts = ts_now & ~TSMASK; 75 ts |= options; 76 if (ts > ts_now) { 77 ts >>= TSBITS; 78 ts--; 79 ts <<= TSBITS; 80 ts |= options; 81 } 82 return ts; 83 } 84 85 86 static __u32 secure_tcp_syn_cookie(__be32 saddr, __be32 daddr, __be16 sport, 87 __be16 dport, __u32 sseq, __u32 data) 88 { 89 /* 90 * Compute the secure sequence number. 91 * The output should be: 92 * HASH(sec1,saddr,sport,daddr,dport,sec1) + sseq + (count * 2^24) 93 * + (HASH(sec2,saddr,sport,daddr,dport,count,sec2) % 2^24). 94 * Where sseq is their sequence number and count increases every 95 * minute by 1. 96 * As an extra hack, we add a small "data" value that encodes the 97 * MSS into the second hash value. 98 */ 99 u32 count = tcp_cookie_time(); 100 return (cookie_hash(saddr, daddr, sport, dport, 0, 0) + 101 sseq + (count << COOKIEBITS) + 102 ((cookie_hash(saddr, daddr, sport, dport, count, 1) + data) 103 & COOKIEMASK)); 104 } 105 106 /* 107 * This retrieves the small "data" value from the syncookie. 108 * If the syncookie is bad, the data returned will be out of 109 * range. This must be checked by the caller. 110 * 111 * The count value used to generate the cookie must be less than 112 * MAX_SYNCOOKIE_AGE minutes in the past. 113 * The return value (__u32)-1 if this test fails. 114 */ 115 static __u32 check_tcp_syn_cookie(__u32 cookie, __be32 saddr, __be32 daddr, 116 __be16 sport, __be16 dport, __u32 sseq) 117 { 118 u32 diff, count = tcp_cookie_time(); 119 120 /* Strip away the layers from the cookie */ 121 cookie -= cookie_hash(saddr, daddr, sport, dport, 0, 0) + sseq; 122 123 /* Cookie is now reduced to (count * 2^24) ^ (hash % 2^24) */ 124 diff = (count - (cookie >> COOKIEBITS)) & ((__u32) -1 >> COOKIEBITS); 125 if (diff >= MAX_SYNCOOKIE_AGE) 126 return (__u32)-1; 127 128 return (cookie - 129 cookie_hash(saddr, daddr, sport, dport, count - diff, 1)) 130 & COOKIEMASK; /* Leaving the data behind */ 131 } 132 133 /* 134 * MSS Values are chosen based on the 2011 paper 135 * 'An Analysis of TCP Maximum Segement Sizes' by S. Alcock and R. Nelson. 136 * Values .. 137 * .. lower than 536 are rare (< 0.2%) 138 * .. between 537 and 1299 account for less than < 1.5% of observed values 139 * .. in the 1300-1349 range account for about 15 to 20% of observed mss values 140 * .. exceeding 1460 are very rare (< 0.04%) 141 * 142 * 1460 is the single most frequently announced mss value (30 to 46% depending 143 * on monitor location). Table must be sorted. 144 */ 145 static __u16 const msstab[] = { 146 536, 147 1300, 148 1440, /* 1440, 1452: PPPoE */ 149 1460, 150 }; 151 152 /* 153 * Generate a syncookie. mssp points to the mss, which is returned 154 * rounded down to the value encoded in the cookie. 155 */ 156 u32 __cookie_v4_init_sequence(const struct iphdr *iph, const struct tcphdr *th, 157 u16 *mssp) 158 { 159 int mssind; 160 const __u16 mss = *mssp; 161 162 for (mssind = ARRAY_SIZE(msstab) - 1; mssind ; mssind--) 163 if (mss >= msstab[mssind]) 164 break; 165 *mssp = msstab[mssind]; 166 167 return secure_tcp_syn_cookie(iph->saddr, iph->daddr, 168 th->source, th->dest, ntohl(th->seq), 169 mssind); 170 } 171 EXPORT_SYMBOL_GPL(__cookie_v4_init_sequence); 172 173 __u32 cookie_v4_init_sequence(struct sock *sk, const struct sk_buff *skb, 174 __u16 *mssp) 175 { 176 const struct iphdr *iph = ip_hdr(skb); 177 const struct tcphdr *th = tcp_hdr(skb); 178 179 tcp_synq_overflow(sk); 180 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESSENT); 181 182 return __cookie_v4_init_sequence(iph, th, mssp); 183 } 184 185 /* 186 * Check if a ack sequence number is a valid syncookie. 187 * Return the decoded mss if it is, or 0 if not. 188 */ 189 int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th, 190 u32 cookie) 191 { 192 __u32 seq = ntohl(th->seq) - 1; 193 __u32 mssind = check_tcp_syn_cookie(cookie, iph->saddr, iph->daddr, 194 th->source, th->dest, seq); 195 196 return mssind < ARRAY_SIZE(msstab) ? msstab[mssind] : 0; 197 } 198 EXPORT_SYMBOL_GPL(__cookie_v4_check); 199 200 static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb, 201 struct request_sock *req, 202 struct dst_entry *dst) 203 { 204 struct inet_connection_sock *icsk = inet_csk(sk); 205 struct sock *child; 206 207 child = icsk->icsk_af_ops->syn_recv_sock(sk, skb, req, dst); 208 if (child) 209 inet_csk_reqsk_queue_add(sk, req, child); 210 else 211 reqsk_free(req); 212 213 return child; 214 } 215 216 217 /* 218 * when syncookies are in effect and tcp timestamps are enabled we stored 219 * additional tcp options in the timestamp. 220 * This extracts these options from the timestamp echo. 221 * 222 * The lowest 4 bits store snd_wscale. 223 * next 2 bits indicate SACK and ECN support. 224 * 225 * return false if we decode an option that should not be. 226 */ 227 bool cookie_check_timestamp(struct tcp_options_received *tcp_opt, 228 struct net *net, bool *ecn_ok) 229 { 230 /* echoed timestamp, lowest bits contain options */ 231 u32 options = tcp_opt->rcv_tsecr & TSMASK; 232 233 if (!tcp_opt->saw_tstamp) { 234 tcp_clear_options(tcp_opt); 235 return true; 236 } 237 238 if (!sysctl_tcp_timestamps) 239 return false; 240 241 tcp_opt->sack_ok = (options & (1 << 4)) ? TCP_SACK_SEEN : 0; 242 *ecn_ok = (options >> 5) & 1; 243 if (*ecn_ok && !net->ipv4.sysctl_tcp_ecn) 244 return false; 245 246 if (tcp_opt->sack_ok && !sysctl_tcp_sack) 247 return false; 248 249 if ((options & 0xf) == 0xf) 250 return true; /* no window scaling */ 251 252 tcp_opt->wscale_ok = 1; 253 tcp_opt->snd_wscale = options & 0xf; 254 return sysctl_tcp_window_scaling != 0; 255 } 256 EXPORT_SYMBOL(cookie_check_timestamp); 257 258 struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb) 259 { 260 struct ip_options *opt = &TCP_SKB_CB(skb)->header.h4.opt; 261 struct tcp_options_received tcp_opt; 262 struct inet_request_sock *ireq; 263 struct tcp_request_sock *treq; 264 struct tcp_sock *tp = tcp_sk(sk); 265 const struct tcphdr *th = tcp_hdr(skb); 266 __u32 cookie = ntohl(th->ack_seq) - 1; 267 struct sock *ret = sk; 268 struct request_sock *req; 269 int mss; 270 struct rtable *rt; 271 __u8 rcv_wscale; 272 bool ecn_ok = false; 273 struct flowi4 fl4; 274 275 if (!sysctl_tcp_syncookies || !th->ack || th->rst) 276 goto out; 277 278 if (tcp_synq_no_recent_overflow(sk) || 279 (mss = __cookie_v4_check(ip_hdr(skb), th, cookie)) == 0) { 280 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED); 281 goto out; 282 } 283 284 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESRECV); 285 286 /* check for timestamp cookie support */ 287 memset(&tcp_opt, 0, sizeof(tcp_opt)); 288 tcp_parse_options(skb, &tcp_opt, 0, NULL); 289 290 if (!cookie_check_timestamp(&tcp_opt, sock_net(sk), &ecn_ok)) 291 goto out; 292 293 ret = NULL; 294 req = inet_reqsk_alloc(&tcp_request_sock_ops); /* for safety */ 295 if (!req) 296 goto out; 297 298 ireq = inet_rsk(req); 299 treq = tcp_rsk(req); 300 treq->rcv_isn = ntohl(th->seq) - 1; 301 treq->snt_isn = cookie; 302 req->mss = mss; 303 ireq->ir_num = ntohs(th->dest); 304 ireq->ir_rmt_port = th->source; 305 ireq->ir_loc_addr = ip_hdr(skb)->daddr; 306 ireq->ir_rmt_addr = ip_hdr(skb)->saddr; 307 ireq->ir_mark = inet_request_mark(sk, skb); 308 ireq->ecn_ok = ecn_ok; 309 ireq->snd_wscale = tcp_opt.snd_wscale; 310 ireq->sack_ok = tcp_opt.sack_ok; 311 ireq->wscale_ok = tcp_opt.wscale_ok; 312 ireq->tstamp_ok = tcp_opt.saw_tstamp; 313 req->ts_recent = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsval : 0; 314 treq->snt_synack = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsecr : 0; 315 treq->listener = NULL; 316 317 /* We throwed the options of the initial SYN away, so we hope 318 * the ACK carries the same options again (see RFC1122 4.2.3.8) 319 */ 320 ireq->opt = tcp_v4_save_options(skb); 321 322 if (security_inet_conn_request(sk, skb, req)) { 323 reqsk_free(req); 324 goto out; 325 } 326 327 req->expires = 0UL; 328 req->num_retrans = 0; 329 330 /* 331 * We need to lookup the route here to get at the correct 332 * window size. We should better make sure that the window size 333 * hasn't changed since we received the original syn, but I see 334 * no easy way to do this. 335 */ 336 flowi4_init_output(&fl4, sk->sk_bound_dev_if, ireq->ir_mark, 337 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE, IPPROTO_TCP, 338 inet_sk_flowi_flags(sk), 339 opt->srr ? opt->faddr : ireq->ir_rmt_addr, 340 ireq->ir_loc_addr, th->source, th->dest); 341 security_req_classify_flow(req, flowi4_to_flowi(&fl4)); 342 rt = ip_route_output_key(sock_net(sk), &fl4); 343 if (IS_ERR(rt)) { 344 reqsk_free(req); 345 goto out; 346 } 347 348 /* Try to redo what tcp_v4_send_synack did. */ 349 req->window_clamp = tp->window_clamp ? :dst_metric(&rt->dst, RTAX_WINDOW); 350 351 tcp_select_initial_window(tcp_full_space(sk), req->mss, 352 &req->rcv_wnd, &req->window_clamp, 353 ireq->wscale_ok, &rcv_wscale, 354 dst_metric(&rt->dst, RTAX_INITRWND)); 355 356 ireq->rcv_wscale = rcv_wscale; 357 358 ret = get_cookie_sock(sk, skb, req, &rt->dst); 359 /* ip_queue_xmit() depends on our flow being setup 360 * Normal sockets get it right from inet_csk_route_child_sock() 361 */ 362 if (ret) 363 inet_sk(ret)->cork.fl.u.ip4 = fl4; 364 out: return ret; 365 } 366