blob: 2da1be0589a9e7f2fb2cb6c0383e0452df570207 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Syncookies implementation for the Linux kernel
3 *
4 * Copyright (C) 1997 Andi Kleen
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +09005 * Based on ideas by D.J.Bernstein and Eric Schenk.
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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.
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090011 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * $Id: syncookies.c,v 1.18 2002/02/01 22:01:04 davem Exp $
13 *
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090014 * Missing: IPv6 support.
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 */
16
17#include <linux/tcp.h>
18#include <linux/slab.h>
19#include <linux/random.h>
20#include <linux/cryptohash.h>
21#include <linux/kernel.h>
22#include <net/tcp.h>
23
24extern int sysctl_tcp_syncookies;
25
26static __u32 syncookie_secret[2][16-3+SHA_DIGEST_WORDS];
27
28static __init int init_syncookies(void)
29{
30 get_random_bytes(syncookie_secret, sizeof(syncookie_secret));
31 return 0;
32}
33module_init(init_syncookies);
34
35#define COOKIEBITS 24 /* Upper bits store count */
36#define COOKIEMASK (((__u32)1 << COOKIEBITS) - 1)
37
Al Viro714e85b2006-11-14 20:51:49 -080038static u32 cookie_hash(__be32 saddr, __be32 daddr, __be16 sport, __be16 dport,
Linus Torvalds1da177e2005-04-16 15:20:36 -070039 u32 count, int c)
40{
41 __u32 tmp[16 + 5 + SHA_WORKSPACE_WORDS];
42
43 memcpy(tmp + 3, syncookie_secret[c], sizeof(syncookie_secret[c]));
Al Viro714e85b2006-11-14 20:51:49 -080044 tmp[0] = (__force u32)saddr;
45 tmp[1] = (__force u32)daddr;
46 tmp[2] = ((__force u32)sport << 16) + (__force u32)dport;
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 tmp[3] = count;
48 sha_transform(tmp + 16, (__u8 *)tmp, tmp + 16 + 5);
49
50 return tmp[17];
51}
52
Al Viro714e85b2006-11-14 20:51:49 -080053static __u32 secure_tcp_syn_cookie(__be32 saddr, __be32 daddr, __be16 sport,
54 __be16 dport, __u32 sseq, __u32 count,
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 __u32 data)
56{
57 /*
58 * Compute the secure sequence number.
59 * The output should be:
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +090060 * HASH(sec1,saddr,sport,daddr,dport,sec1) + sseq + (count * 2^24)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 * + (HASH(sec2,saddr,sport,daddr,dport,count,sec2) % 2^24).
62 * Where sseq is their sequence number and count increases every
63 * minute by 1.
64 * As an extra hack, we add a small "data" value that encodes the
65 * MSS into the second hash value.
66 */
67
68 return (cookie_hash(saddr, daddr, sport, dport, 0, 0) +
69 sseq + (count << COOKIEBITS) +
70 ((cookie_hash(saddr, daddr, sport, dport, count, 1) + data)
71 & COOKIEMASK));
72}
73
74/*
75 * This retrieves the small "data" value from the syncookie.
76 * If the syncookie is bad, the data returned will be out of
77 * range. This must be checked by the caller.
78 *
79 * The count value used to generate the cookie must be within
80 * "maxdiff" if the current (passed-in) "count". The return value
81 * is (__u32)-1 if this test fails.
82 */
Al Viro714e85b2006-11-14 20:51:49 -080083static __u32 check_tcp_syn_cookie(__u32 cookie, __be32 saddr, __be32 daddr,
84 __be16 sport, __be16 dport, __u32 sseq,
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 __u32 count, __u32 maxdiff)
86{
87 __u32 diff;
88
89 /* Strip away the layers from the cookie */
90 cookie -= cookie_hash(saddr, daddr, sport, dport, 0, 0) + sseq;
91
92 /* Cookie is now reduced to (count * 2^24) ^ (hash % 2^24) */
93 diff = (count - (cookie >> COOKIEBITS)) & ((__u32) - 1 >> COOKIEBITS);
94 if (diff >= maxdiff)
95 return (__u32)-1;
96
97 return (cookie -
98 cookie_hash(saddr, daddr, sport, dport, count - diff, 1))
99 & COOKIEMASK; /* Leaving the data behind */
100}
101
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900102/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 * This table has to be sorted and terminated with (__u16)-1.
104 * XXX generate a better table.
105 * Unresolved Issues: HIPPI with a 64k MSS is not well supported.
106 */
107static __u16 const msstab[] = {
108 64 - 1,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900109 256 - 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 512 - 1,
111 536 - 1,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900112 1024 - 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 1440 - 1,
114 1460 - 1,
115 4312 - 1,
116 (__u16)-1
117};
118/* The number doesn't include the -1 terminator */
119#define NUM_MSS (ARRAY_SIZE(msstab) - 1)
120
121/*
122 * Generate a syncookie. mssp points to the mss, which is returned
123 * rounded down to the value encoded in the cookie.
124 */
125__u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, __u16 *mssp)
126{
127 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700128 const struct iphdr *iph = ip_hdr(skb);
129 const struct tcphdr *th = tcp_hdr(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 int mssind;
131 const __u16 mss = *mssp;
132
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 tp->last_synq_overflow = jiffies;
134
135 /* XXX sort msstab[] by probability? Binary search? */
136 for (mssind = 0; mss > msstab[mssind + 1]; mssind++)
137 ;
138 *mssp = msstab[mssind] + 1;
139
140 NET_INC_STATS_BH(LINUX_MIB_SYNCOOKIESSENT);
141
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700142 return secure_tcp_syn_cookie(iph->saddr, iph->daddr,
143 th->source, th->dest, ntohl(th->seq),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 jiffies / (HZ * 60), mssind);
145}
146
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900147/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 * This (misnamed) value is the age of syncookie which is permitted.
149 * Its ideal value should be dependent on TCP_TIMEOUT_INIT and
150 * sysctl_tcp_retries1. It's a rather complicated formula (exponential
151 * backoff) to compute at runtime so it's currently hardcoded here.
152 */
153#define COUNTER_TRIES 4
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900154/*
155 * Check if a ack sequence number is a valid syncookie.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 * Return the decoded mss if it is, or 0 if not.
157 */
158static inline int cookie_check(struct sk_buff *skb, __u32 cookie)
159{
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700160 const struct iphdr *iph = ip_hdr(skb);
161 const struct tcphdr *th = tcp_hdr(skb);
162 __u32 seq = ntohl(th->seq) - 1;
163 __u32 mssind = check_tcp_syn_cookie(cookie, iph->saddr, iph->daddr,
164 th->source, th->dest, seq,
165 jiffies / (HZ * 60),
166 COUNTER_TRIES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
168 return mssind < NUM_MSS ? msstab[mssind] + 1 : 0;
169}
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb,
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700172 struct request_sock *req,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 struct dst_entry *dst)
174{
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800175 struct inet_connection_sock *icsk = inet_csk(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 struct sock *child;
177
Arnaldo Carvalho de Melo8292a172005-12-13 23:15:52 -0800178 child = icsk->icsk_af_ops->syn_recv_sock(sk, skb, req, dst);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179 if (child)
Arnaldo Carvalho de Melo463c84b2005-08-09 20:10:42 -0700180 inet_csk_reqsk_queue_add(sk, req, child);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 else
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700182 reqsk_free(req);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184 return child;
185}
186
187struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
188 struct ip_options *opt)
189{
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700190 struct inet_request_sock *ireq;
191 struct tcp_request_sock *treq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 struct tcp_sock *tp = tcp_sk(sk);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700193 const struct tcphdr *th = tcp_hdr(skb);
194 __u32 cookie = ntohl(th->ack_seq) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 struct sock *ret = sk;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900196 struct request_sock *req;
197 int mss;
198 struct rtable *rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 __u8 rcv_wscale;
200
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700201 if (!sysctl_tcp_syncookies || !th->ack)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 goto out;
203
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900204 if (time_after(jiffies, tp->last_synq_overflow + TCP_TIMEOUT_INIT) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 (mss = cookie_check(skb, cookie)) == 0) {
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900206 NET_INC_STATS_BH(LINUX_MIB_SYNCOOKIESFAILED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 goto out;
208 }
209
210 NET_INC_STATS_BH(LINUX_MIB_SYNCOOKIESRECV);
211
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 ret = NULL;
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700213 req = reqsk_alloc(&tcp_request_sock_ops); /* for safety */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 if (!req)
215 goto out;
216
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700217 if (security_inet_conn_request(sk, skb, req)) {
218 reqsk_free(req);
219 goto out;
220 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700221 ireq = inet_rsk(req);
222 treq = tcp_rsk(req);
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700223 treq->rcv_isn = ntohl(th->seq) - 1;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900224 treq->snt_isn = cookie;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 req->mss = mss;
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700226 ireq->rmt_port = th->source;
Arnaldo Carvalho de Meloeddc9ec2007-04-20 22:47:35 -0700227 ireq->loc_addr = ip_hdr(skb)->daddr;
228 ireq->rmt_addr = ip_hdr(skb)->saddr;
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700229 ireq->opt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
231 /* We throwed the options of the initial SYN away, so we hope
232 * the ACK carries the same options again (see RFC1122 4.2.3.8)
233 */
234 if (opt && opt->optlen) {
235 int opt_size = sizeof(struct ip_options) + opt->optlen;
236
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700237 ireq->opt = kmalloc(opt_size, GFP_ATOMIC);
238 if (ireq->opt != NULL && ip_options_echo(ireq->opt, skb)) {
239 kfree(ireq->opt);
240 ireq->opt = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 }
242 }
243
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700244 ireq->snd_wscale = ireq->rcv_wscale = ireq->tstamp_ok = 0;
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900245 ireq->wscale_ok = ireq->sack_ok = 0;
246 req->expires = 0UL;
247 req->retrans = 0;
248
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 /*
250 * We need to lookup the route here to get at the correct
251 * window size. We should better make sure that the window size
252 * hasn't changed since we received the original syn, but I see
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900253 * no easy way to do this.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 */
255 {
256 struct flowi fl = { .nl_u = { .ip4_u =
257 { .daddr = ((opt && opt->srr) ?
258 opt->faddr :
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700259 ireq->rmt_addr),
260 .saddr = ireq->loc_addr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 .tos = RT_CONN_FLAGS(sk) } },
262 .proto = IPPROTO_TCP,
263 .uli_u = { .ports =
Arnaldo Carvalho de Meloaa8223c2007-04-10 21:04:22 -0700264 { .sport = th->dest,
265 .dport = th->source } } };
Venkat Yekkirala4237c752006-07-24 23:32:50 -0700266 security_req_classify_flow(req, &fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 if (ip_route_output_key(&rt, &fl)) {
Arnaldo Carvalho de Melo60236fd2005-06-18 22:47:21 -0700268 reqsk_free(req);
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900269 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 }
271 }
272
273 /* Try to redo what tcp_v4_send_synack did. */
274 req->window_clamp = dst_metric(&rt->u.dst, RTAX_WINDOW);
275 tcp_select_initial_window(tcp_full_space(sk), req->mss,
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900276 &req->rcv_wnd, &req->window_clamp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 0, &rcv_wscale);
278 /* BTW win scale with syncookies is 0 by definition */
YOSHIFUJI Hideakie905a9e2007-02-09 23:24:47 +0900279 ireq->rcv_wscale = rcv_wscale;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281 ret = get_cookie_sock(sk, skb, req, &rt->u.dst);
282out: return ret;
283}