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]; 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 = __get_cpu_var(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, struct sk_buff *skb, __u16 *mssp) 174 { 175 const struct iphdr *iph = ip_hdr(skb); 176 const struct tcphdr *th = tcp_hdr(skb); 177 178 tcp_synq_overflow(sk); 179 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESSENT); 180 181 return __cookie_v4_init_sequence(iph, th, mssp); 182 } 183 184 /* 185 * Check if a ack sequence number is a valid syncookie. 186 * Return the decoded mss if it is, or 0 if not. 187 */ 188 int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th, 189 u32 cookie) 190 { 191 __u32 seq = ntohl(th->seq) - 1; 192 __u32 mssind = check_tcp_syn_cookie(cookie, iph->saddr, iph->daddr, 193 th->source, th->dest, seq); 194 195 return mssind < ARRAY_SIZE(msstab) ? msstab[mssind] : 0; 196 } 197 EXPORT_SYMBOL_GPL(__cookie_v4_check); 198 199 static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb, 200 struct request_sock *req, 201 struct dst_entry *dst) 202 { 203 struct inet_connection_sock *icsk = inet_csk(sk); 204 struct sock *child; 205 206 child = icsk->icsk_af_ops->syn_recv_sock(sk, skb, req, dst); 207 if (child) 208 inet_csk_reqsk_queue_add(sk, req, child); 209 else 210 reqsk_free(req); 211 212 return child; 213 } 214 215 216 /* 217 * when syncookies are in effect and tcp timestamps are enabled we stored 218 * additional tcp options in the timestamp. 219 * This extracts these options from the timestamp echo. 220 * 221 * The lowest 4 bits store snd_wscale. 222 * next 2 bits indicate SACK and ECN support. 223 * 224 * return false if we decode an option that should not be. 225 */ 226 bool cookie_check_timestamp(struct tcp_options_received *tcp_opt, 227 struct net *net, bool *ecn_ok) 228 { 229 /* echoed timestamp, lowest bits contain options */ 230 u32 options = tcp_opt->rcv_tsecr & TSMASK; 231 232 if (!tcp_opt->saw_tstamp) { 233 tcp_clear_options(tcp_opt); 234 return true; 235 } 236 237 if (!sysctl_tcp_timestamps) 238 return false; 239 240 tcp_opt->sack_ok = (options & (1 << 4)) ? TCP_SACK_SEEN : 0; 241 *ecn_ok = (options >> 5) & 1; 242 if (*ecn_ok && !net->ipv4.sysctl_tcp_ecn) 243 return false; 244 245 if (tcp_opt->sack_ok && !sysctl_tcp_sack) 246 return false; 247 248 if ((options & 0xf) == 0xf) 249 return true; /* no window scaling */ 250 251 tcp_opt->wscale_ok = 1; 252 tcp_opt->snd_wscale = options & 0xf; 253 return sysctl_tcp_window_scaling != 0; 254 } 255 EXPORT_SYMBOL(cookie_check_timestamp); 256 257 struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb, 258 struct ip_options *opt) 259 { 260 struct tcp_options_received tcp_opt; 261 struct inet_request_sock *ireq; 262 struct tcp_request_sock *treq; 263 struct tcp_sock *tp = tcp_sk(sk); 264 const struct tcphdr *th = tcp_hdr(skb); 265 __u32 cookie = ntohl(th->ack_seq) - 1; 266 struct sock *ret = sk; 267 struct request_sock *req; 268 int mss; 269 struct rtable *rt; 270 __u8 rcv_wscale; 271 bool ecn_ok = false; 272 struct flowi4 fl4; 273 274 if (!sysctl_tcp_syncookies || !th->ack || th->rst) 275 goto out; 276 277 if (tcp_synq_no_recent_overflow(sk) || 278 (mss = __cookie_v4_check(ip_hdr(skb), th, cookie)) == 0) { 279 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESFAILED); 280 goto out; 281 } 282 283 NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SYNCOOKIESRECV); 284 285 /* check for timestamp cookie support */ 286 memset(&tcp_opt, 0, sizeof(tcp_opt)); 287 tcp_parse_options(skb, &tcp_opt, 0, NULL); 288 289 if (!cookie_check_timestamp(&tcp_opt, sock_net(sk), &ecn_ok)) 290 goto out; 291 292 ret = NULL; 293 req = inet_reqsk_alloc(&tcp_request_sock_ops); /* for safety */ 294 if (!req) 295 goto out; 296 297 ireq = inet_rsk(req); 298 treq = tcp_rsk(req); 299 treq->rcv_isn = ntohl(th->seq) - 1; 300 treq->snt_isn = cookie; 301 req->mss = mss; 302 ireq->ir_num = ntohs(th->dest); 303 ireq->ir_rmt_port = th->source; 304 ireq->ir_loc_addr = ip_hdr(skb)->daddr; 305 ireq->ir_rmt_addr = ip_hdr(skb)->saddr; 306 ireq->ir_mark = inet_request_mark(sk, skb); 307 ireq->ecn_ok = ecn_ok; 308 ireq->snd_wscale = tcp_opt.snd_wscale; 309 ireq->sack_ok = tcp_opt.sack_ok; 310 ireq->wscale_ok = tcp_opt.wscale_ok; 311 ireq->tstamp_ok = tcp_opt.saw_tstamp; 312 req->ts_recent = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsval : 0; 313 treq->snt_synack = tcp_opt.saw_tstamp ? tcp_opt.rcv_tsecr : 0; 314 treq->listener = NULL; 315 316 /* We throwed the options of the initial SYN away, so we hope 317 * the ACK carries the same options again (see RFC1122 4.2.3.8) 318 */ 319 if (opt && opt->optlen) { 320 int opt_size = sizeof(struct ip_options_rcu) + opt->optlen; 321 322 ireq->opt = kmalloc(opt_size, GFP_ATOMIC); 323 if (ireq->opt != NULL && ip_options_echo(&ireq->opt->opt, skb)) { 324 kfree(ireq->opt); 325 ireq->opt = NULL; 326 } 327 } 328 329 if (security_inet_conn_request(sk, skb, req)) { 330 reqsk_free(req); 331 goto out; 332 } 333 334 req->expires = 0UL; 335 req->num_retrans = 0; 336 337 /* 338 * We need to lookup the route here to get at the correct 339 * window size. We should better make sure that the window size 340 * hasn't changed since we received the original syn, but I see 341 * no easy way to do this. 342 */ 343 flowi4_init_output(&fl4, sk->sk_bound_dev_if, ireq->ir_mark, 344 RT_CONN_FLAGS(sk), RT_SCOPE_UNIVERSE, IPPROTO_TCP, 345 inet_sk_flowi_flags(sk), 346 (opt && opt->srr) ? opt->faddr : ireq->ir_rmt_addr, 347 ireq->ir_loc_addr, th->source, th->dest); 348 security_req_classify_flow(req, flowi4_to_flowi(&fl4)); 349 rt = ip_route_output_key(sock_net(sk), &fl4); 350 if (IS_ERR(rt)) { 351 reqsk_free(req); 352 goto out; 353 } 354 355 /* Try to redo what tcp_v4_send_synack did. */ 356 req->window_clamp = tp->window_clamp ? :dst_metric(&rt->dst, RTAX_WINDOW); 357 358 tcp_select_initial_window(tcp_full_space(sk), req->mss, 359 &req->rcv_wnd, &req->window_clamp, 360 ireq->wscale_ok, &rcv_wscale, 361 dst_metric(&rt->dst, RTAX_INITRWND)); 362 363 ireq->rcv_wscale = rcv_wscale; 364 365 ret = get_cookie_sock(sk, skb, req, &rt->dst); 366 /* ip_queue_xmit() depends on our flow being setup 367 * Normal sockets get it right from inet_csk_route_child_sock() 368 */ 369 if (ret) 370 inet_sk(ret)->cork.fl.u.ip4 = fl4; 371 out: return ret; 372 } 373