timers.c 8.0 KB

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