2 * xfrm_replay.c - xfrm replay detection, derived from xfrm_state.c.
4 * Copyright (C) 2010 secunet Security Networks AG
5 * Copyright (C) 2010 Steffen Klassert <steffen.klassert@secunet.com>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
23 static void xfrm_replay_notify(struct xfrm_state *x, int event)
26 /* we send notify messages in case
27 * 1. we updated on of the sequence numbers, and the seqno difference
28 * is at least x->replay_maxdiff, in this case we also update the
29 * timeout of our timer function
30 * 2. if x->replay_maxage has elapsed since last update,
31 * and there were changes
33 * The state structure must be locked!
37 case XFRM_REPLAY_UPDATE:
38 if (x->replay_maxdiff &&
39 (x->replay.seq - x->preplay.seq < x->replay_maxdiff) &&
40 (x->replay.oseq - x->preplay.oseq < x->replay_maxdiff)) {
41 if (x->xflags & XFRM_TIME_DEFER)
42 event = XFRM_REPLAY_TIMEOUT;
49 case XFRM_REPLAY_TIMEOUT:
50 if (memcmp(&x->replay, &x->preplay,
51 sizeof(struct xfrm_replay_state)) == 0) {
52 x->xflags |= XFRM_TIME_DEFER;
59 memcpy(&x->preplay, &x->replay, sizeof(struct xfrm_replay_state));
60 c.event = XFRM_MSG_NEWAE;
61 c.data.aevent = event;
62 km_state_notify(x, &c);
64 if (x->replay_maxage &&
65 !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
66 x->xflags &= ~XFRM_TIME_DEFER;
69 static int xfrm_replay_overflow(struct xfrm_state *x, struct sk_buff *skb)
72 struct net *net = xs_net(x);
74 if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
75 XFRM_SKB_CB(skb)->seq.output.low = ++x->replay.oseq;
76 if (unlikely(x->replay.oseq == 0)) {
78 xfrm_audit_state_replay_overflow(x, skb);
83 if (xfrm_aevent_is_on(net))
84 x->repl->notify(x, XFRM_REPLAY_UPDATE);
90 static int xfrm_replay_check(struct xfrm_state *x,
91 struct sk_buff *skb, __be32 net_seq)
94 u32 seq = ntohl(net_seq);
96 if (unlikely(seq == 0))
99 if (likely(seq > x->replay.seq))
102 diff = x->replay.seq - seq;
103 if (diff >= min_t(unsigned int, x->props.replay_window,
104 sizeof(x->replay.bitmap) * 8)) {
105 x->stats.replay_window++;
109 if (x->replay.bitmap & (1U << diff)) {
116 xfrm_audit_state_replay(x, skb, net_seq);
120 static void xfrm_replay_advance(struct xfrm_state *x, __be32 net_seq)
123 u32 seq = ntohl(net_seq);
125 if (!x->props.replay_window)
128 if (seq > x->replay.seq) {
129 diff = seq - x->replay.seq;
130 if (diff < x->props.replay_window)
131 x->replay.bitmap = ((x->replay.bitmap) << diff) | 1;
133 x->replay.bitmap = 1;
136 diff = x->replay.seq - seq;
137 x->replay.bitmap |= (1U << diff);
140 if (xfrm_aevent_is_on(xs_net(x)))
141 xfrm_replay_notify(x, XFRM_REPLAY_UPDATE);
144 static int xfrm_replay_overflow_bmp(struct xfrm_state *x, struct sk_buff *skb)
147 struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
148 struct net *net = xs_net(x);
150 if (x->type->flags & XFRM_TYPE_REPLAY_PROT) {
151 XFRM_SKB_CB(skb)->seq.output.low = ++replay_esn->oseq;
152 if (unlikely(replay_esn->oseq == 0)) {
154 xfrm_audit_state_replay_overflow(x, skb);
159 if (xfrm_aevent_is_on(net))
160 x->repl->notify(x, XFRM_REPLAY_UPDATE);
166 static int xfrm_replay_check_bmp(struct xfrm_state *x,
167 struct sk_buff *skb, __be32 net_seq)
169 unsigned int bitnr, nr;
170 struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
171 u32 seq = ntohl(net_seq);
172 u32 diff = replay_esn->seq - seq;
173 u32 pos = (replay_esn->seq - 1) % replay_esn->replay_window;
175 if (unlikely(seq == 0))
178 if (likely(seq > replay_esn->seq))
181 if (diff >= replay_esn->replay_window) {
182 x->stats.replay_window++;
187 bitnr = (pos - diff) % replay_esn->replay_window;
189 bitnr = bitnr & 0x1F;
190 if (replay_esn->bmp[nr] & (1U << bitnr))
193 bitnr = replay_esn->replay_window - (diff - pos);
195 bitnr = bitnr & 0x1F;
196 if (replay_esn->bmp[nr] & (1U << bitnr))
204 xfrm_audit_state_replay(x, skb, net_seq);
208 static void xfrm_replay_advance_bmp(struct xfrm_state *x, __be32 net_seq)
210 unsigned int bitnr, nr, i;
212 struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
213 u32 seq = ntohl(net_seq);
214 u32 pos = (replay_esn->seq - 1) % replay_esn->replay_window;
216 if (!replay_esn->replay_window)
219 if (seq > replay_esn->seq) {
220 diff = seq - replay_esn->seq;
222 if (diff < replay_esn->replay_window) {
223 for (i = 1; i < diff; i++) {
224 bitnr = (pos + i) % replay_esn->replay_window;
226 bitnr = bitnr & 0x1F;
227 replay_esn->bmp[nr] &= ~(1U << bitnr);
230 bitnr = (pos + diff) % replay_esn->replay_window;
232 bitnr = bitnr & 0x1F;
233 replay_esn->bmp[nr] |= (1U << bitnr);
235 nr = replay_esn->replay_window >> 5;
236 for (i = 0; i <= nr; i++)
237 replay_esn->bmp[i] = 0;
239 bitnr = (pos + diff) % replay_esn->replay_window;
241 bitnr = bitnr & 0x1F;
242 replay_esn->bmp[nr] |= (1U << bitnr);
245 replay_esn->seq = seq;
247 diff = replay_esn->seq - seq;
250 bitnr = (pos - diff) % replay_esn->replay_window;
252 bitnr = bitnr & 0x1F;
253 replay_esn->bmp[nr] |= (1U << bitnr);
255 bitnr = replay_esn->replay_window - (diff - pos);
257 bitnr = bitnr & 0x1F;
258 replay_esn->bmp[nr] |= (1U << bitnr);
262 if (xfrm_aevent_is_on(xs_net(x)))
263 xfrm_replay_notify(x, XFRM_REPLAY_UPDATE);
266 static void xfrm_replay_notify_bmp(struct xfrm_state *x, int event)
269 struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
270 struct xfrm_replay_state_esn *preplay_esn = x->preplay_esn;
272 /* we send notify messages in case
273 * 1. we updated on of the sequence numbers, and the seqno difference
274 * is at least x->replay_maxdiff, in this case we also update the
275 * timeout of our timer function
276 * 2. if x->replay_maxage has elapsed since last update,
277 * and there were changes
279 * The state structure must be locked!
283 case XFRM_REPLAY_UPDATE:
284 if (x->replay_maxdiff &&
285 (replay_esn->seq - preplay_esn->seq < x->replay_maxdiff) &&
286 (replay_esn->oseq - preplay_esn->oseq < x->replay_maxdiff)) {
287 if (x->xflags & XFRM_TIME_DEFER)
288 event = XFRM_REPLAY_TIMEOUT;
295 case XFRM_REPLAY_TIMEOUT:
296 if (memcmp(x->replay_esn, x->preplay_esn,
297 xfrm_replay_state_esn_len(replay_esn)) == 0) {
298 x->xflags |= XFRM_TIME_DEFER;
305 memcpy(x->preplay_esn, x->replay_esn,
306 xfrm_replay_state_esn_len(replay_esn));
307 c.event = XFRM_MSG_NEWAE;
308 c.data.aevent = event;
309 km_state_notify(x, &c);
311 if (x->replay_maxage &&
312 !mod_timer(&x->rtimer, jiffies + x->replay_maxage))
313 x->xflags &= ~XFRM_TIME_DEFER;
316 static struct xfrm_replay xfrm_replay_legacy = {
317 .advance = xfrm_replay_advance,
318 .check = xfrm_replay_check,
319 .notify = xfrm_replay_notify,
320 .overflow = xfrm_replay_overflow,
323 static struct xfrm_replay xfrm_replay_bmp = {
324 .advance = xfrm_replay_advance_bmp,
325 .check = xfrm_replay_check_bmp,
326 .notify = xfrm_replay_notify_bmp,
327 .overflow = xfrm_replay_overflow_bmp,
330 int xfrm_init_replay(struct xfrm_state *x)
332 struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
335 if (replay_esn->replay_window >
336 replay_esn->bmp_len * sizeof(__u32))
339 x->repl = &xfrm_replay_bmp;
341 x->repl = &xfrm_replay_legacy;
346 EXPORT_SYMBOL(xfrm_init_replay);