Loading...
Note: File does not exist in v3.15.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2015-2019 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
4 */
5
6#include "timers.h"
7#include "device.h"
8#include "peer.h"
9#include "queueing.h"
10#include "socket.h"
11
12/*
13 * - Timer for retransmitting the handshake if we don't hear back after
14 * `REKEY_TIMEOUT + jitter` ms.
15 *
16 * - Timer for sending empty packet if we have received a packet but after have
17 * not sent one for `KEEPALIVE_TIMEOUT` ms.
18 *
19 * - Timer for initiating new handshake if we have sent a packet but after have
20 * not received one (even empty) for `(KEEPALIVE_TIMEOUT + REKEY_TIMEOUT) +
21 * jitter` ms.
22 *
23 * - Timer for zeroing out all ephemeral keys after `(REJECT_AFTER_TIME * 3)` ms
24 * if no new keys have been received.
25 *
26 * - Timer for, if enabled, sending an empty authenticated packet every user-
27 * specified seconds.
28 */
29
30static inline void mod_peer_timer(struct wg_peer *peer,
31 struct timer_list *timer,
32 unsigned long expires)
33{
34 rcu_read_lock_bh();
35 if (likely(netif_running(peer->device->dev) &&
36 !READ_ONCE(peer->is_dead)))
37 mod_timer(timer, expires);
38 rcu_read_unlock_bh();
39}
40
41static void wg_expired_retransmit_handshake(struct timer_list *timer)
42{
43 struct wg_peer *peer = from_timer(peer, timer,
44 timer_retransmit_handshake);
45
46 if (peer->timer_handshake_attempts > MAX_TIMER_HANDSHAKES) {
47 pr_debug("%s: Handshake for peer %llu (%pISpfsc) did not complete after %d attempts, giving up\n",
48 peer->device->dev->name, peer->internal_id,
49 &peer->endpoint.addr, (int)MAX_TIMER_HANDSHAKES + 2);
50
51 del_timer(&peer->timer_send_keepalive);
52 /* We drop all packets without a keypair and don't try again,
53 * if we try unsuccessfully for too long to make a handshake.
54 */
55 wg_packet_purge_staged_packets(peer);
56
57 /* We set a timer for destroying any residue that might be left
58 * of a partial exchange.
59 */
60 if (!timer_pending(&peer->timer_zero_key_material))
61 mod_peer_timer(peer, &peer->timer_zero_key_material,
62 jiffies + REJECT_AFTER_TIME * 3 * HZ);
63 } else {
64 ++peer->timer_handshake_attempts;
65 pr_debug("%s: Handshake for peer %llu (%pISpfsc) did not complete after %d seconds, retrying (try %d)\n",
66 peer->device->dev->name, peer->internal_id,
67 &peer->endpoint.addr, (int)REKEY_TIMEOUT,
68 peer->timer_handshake_attempts + 1);
69
70 /* We clear the endpoint address src address, in case this is
71 * the cause of trouble.
72 */
73 wg_socket_clear_peer_endpoint_src(peer);
74
75 wg_packet_send_queued_handshake_initiation(peer, true);
76 }
77}
78
79static void wg_expired_send_keepalive(struct timer_list *timer)
80{
81 struct wg_peer *peer = from_timer(peer, timer, timer_send_keepalive);
82
83 wg_packet_send_keepalive(peer);
84 if (peer->timer_need_another_keepalive) {
85 peer->timer_need_another_keepalive = false;
86 mod_peer_timer(peer, &peer->timer_send_keepalive,
87 jiffies + KEEPALIVE_TIMEOUT * HZ);
88 }
89}
90
91static void wg_expired_new_handshake(struct timer_list *timer)
92{
93 struct wg_peer *peer = from_timer(peer, timer, timer_new_handshake);
94
95 pr_debug("%s: Retrying handshake with peer %llu (%pISpfsc) because we stopped hearing back after %d seconds\n",
96 peer->device->dev->name, peer->internal_id,
97 &peer->endpoint.addr, (int)(KEEPALIVE_TIMEOUT + REKEY_TIMEOUT));
98 /* We clear the endpoint address src address, in case this is the cause
99 * of trouble.
100 */
101 wg_socket_clear_peer_endpoint_src(peer);
102 wg_packet_send_queued_handshake_initiation(peer, false);
103}
104
105static void wg_expired_zero_key_material(struct timer_list *timer)
106{
107 struct wg_peer *peer = from_timer(peer, timer, timer_zero_key_material);
108
109 rcu_read_lock_bh();
110 if (!READ_ONCE(peer->is_dead)) {
111 wg_peer_get(peer);
112 if (!queue_work(peer->device->handshake_send_wq,
113 &peer->clear_peer_work))
114 /* If the work was already on the queue, we want to drop
115 * the extra reference.
116 */
117 wg_peer_put(peer);
118 }
119 rcu_read_unlock_bh();
120}
121
122static void wg_queued_expired_zero_key_material(struct work_struct *work)
123{
124 struct wg_peer *peer = container_of(work, struct wg_peer,
125 clear_peer_work);
126
127 pr_debug("%s: Zeroing out all keys for peer %llu (%pISpfsc), since we haven't received a new one in %d seconds\n",
128 peer->device->dev->name, peer->internal_id,
129 &peer->endpoint.addr, (int)REJECT_AFTER_TIME * 3);
130 wg_noise_handshake_clear(&peer->handshake);
131 wg_noise_keypairs_clear(&peer->keypairs);
132 wg_peer_put(peer);
133}
134
135static void wg_expired_send_persistent_keepalive(struct timer_list *timer)
136{
137 struct wg_peer *peer = from_timer(peer, timer,
138 timer_persistent_keepalive);
139
140 if (likely(peer->persistent_keepalive_interval))
141 wg_packet_send_keepalive(peer);
142}
143
144/* Should be called after an authenticated data packet is sent. */
145void wg_timers_data_sent(struct wg_peer *peer)
146{
147 if (!timer_pending(&peer->timer_new_handshake))
148 mod_peer_timer(peer, &peer->timer_new_handshake,
149 jiffies + (KEEPALIVE_TIMEOUT + REKEY_TIMEOUT) * HZ +
150 get_random_u32_below(REKEY_TIMEOUT_JITTER_MAX_JIFFIES));
151}
152
153/* Should be called after an authenticated data packet is received. */
154void wg_timers_data_received(struct wg_peer *peer)
155{
156 if (likely(netif_running(peer->device->dev))) {
157 if (!timer_pending(&peer->timer_send_keepalive))
158 mod_peer_timer(peer, &peer->timer_send_keepalive,
159 jiffies + KEEPALIVE_TIMEOUT * HZ);
160 else
161 peer->timer_need_another_keepalive = true;
162 }
163}
164
165/* Should be called after any type of authenticated packet is sent, whether
166 * keepalive, data, or handshake.
167 */
168void wg_timers_any_authenticated_packet_sent(struct wg_peer *peer)
169{
170 del_timer(&peer->timer_send_keepalive);
171}
172
173/* Should be called after any type of authenticated packet is received, whether
174 * keepalive, data, or handshake.
175 */
176void wg_timers_any_authenticated_packet_received(struct wg_peer *peer)
177{
178 del_timer(&peer->timer_new_handshake);
179}
180
181/* Should be called after a handshake initiation message is sent. */
182void wg_timers_handshake_initiated(struct wg_peer *peer)
183{
184 mod_peer_timer(peer, &peer->timer_retransmit_handshake,
185 jiffies + REKEY_TIMEOUT * HZ +
186 get_random_u32_below(REKEY_TIMEOUT_JITTER_MAX_JIFFIES));
187}
188
189/* Should be called after a handshake response message is received and processed
190 * or when getting key confirmation via the first data message.
191 */
192void wg_timers_handshake_complete(struct wg_peer *peer)
193{
194 del_timer(&peer->timer_retransmit_handshake);
195 peer->timer_handshake_attempts = 0;
196 peer->sent_lastminute_handshake = false;
197 ktime_get_real_ts64(&peer->walltime_last_handshake);
198}
199
200/* Should be called after an ephemeral key is created, which is before sending a
201 * handshake response or after receiving a handshake response.
202 */
203void wg_timers_session_derived(struct wg_peer *peer)
204{
205 mod_peer_timer(peer, &peer->timer_zero_key_material,
206 jiffies + REJECT_AFTER_TIME * 3 * HZ);
207}
208
209/* Should be called before a packet with authentication, whether
210 * keepalive, data, or handshakem is sent, or after one is received.
211 */
212void wg_timers_any_authenticated_packet_traversal(struct wg_peer *peer)
213{
214 if (peer->persistent_keepalive_interval)
215 mod_peer_timer(peer, &peer->timer_persistent_keepalive,
216 jiffies + peer->persistent_keepalive_interval * HZ);
217}
218
219void wg_timers_init(struct wg_peer *peer)
220{
221 timer_setup(&peer->timer_retransmit_handshake,
222 wg_expired_retransmit_handshake, 0);
223 timer_setup(&peer->timer_send_keepalive, wg_expired_send_keepalive, 0);
224 timer_setup(&peer->timer_new_handshake, wg_expired_new_handshake, 0);
225 timer_setup(&peer->timer_zero_key_material,
226 wg_expired_zero_key_material, 0);
227 timer_setup(&peer->timer_persistent_keepalive,
228 wg_expired_send_persistent_keepalive, 0);
229 INIT_WORK(&peer->clear_peer_work, wg_queued_expired_zero_key_material);
230 peer->timer_handshake_attempts = 0;
231 peer->sent_lastminute_handshake = false;
232 peer->timer_need_another_keepalive = false;
233}
234
235void wg_timers_stop(struct wg_peer *peer)
236{
237 timer_delete_sync(&peer->timer_retransmit_handshake);
238 timer_delete_sync(&peer->timer_send_keepalive);
239 timer_delete_sync(&peer->timer_new_handshake);
240 timer_delete_sync(&peer->timer_zero_key_material);
241 timer_delete_sync(&peer->timer_persistent_keepalive);
242 flush_work(&peer->clear_peer_work);
243}