Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2002-2004, Instant802 Networks, Inc. |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 3 | * Copyright 2008, Jouni Malinen <j@w1.fi> |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 4 | * |
| 5 | * This program is free software; you can redistribute it and/or modify |
| 6 | * it under the terms of the GNU General Public License version 2 as |
| 7 | * published by the Free Software Foundation. |
| 8 | */ |
| 9 | |
| 10 | #include <linux/netdevice.h> |
| 11 | #include <linux/types.h> |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 12 | #include <linux/skbuff.h> |
| 13 | #include <linux/compiler.h> |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 14 | #include <linux/ieee80211.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 15 | #include <linux/gfp.h> |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 16 | #include <asm/unaligned.h> |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 17 | #include <net/mac80211.h> |
Johannes Berg | aba83a0b | 2011-07-06 21:59:39 +0200 | [diff] [blame] | 18 | #include <crypto/aes.h> |
Johannes Berg | eb063c1 | 2007-08-28 17:01:53 -0400 | [diff] [blame] | 19 | |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 20 | #include "ieee80211_i.h" |
| 21 | #include "michael.h" |
| 22 | #include "tkip.h" |
| 23 | #include "aes_ccm.h" |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 24 | #include "aes_cmac.h" |
Jouni Malinen | 8ade538 | 2015-01-24 19:52:09 +0200 | [diff] [blame] | 25 | #include "aes_gmac.h" |
Jouni Malinen | 00b9cfa | 2015-01-24 19:52:06 +0200 | [diff] [blame] | 26 | #include "aes_gcm.h" |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 27 | #include "wpa.h" |
| 28 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 29 | ieee80211_tx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 30 | ieee80211_tx_h_michael_mic_add(struct ieee80211_tx_data *tx) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 31 | { |
Jouni Malinen | 747d753 | 2011-02-03 18:34:28 +0200 | [diff] [blame] | 32 | u8 *data, *key, *mic; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 33 | size_t data_len; |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 34 | unsigned int hdrlen; |
| 35 | struct ieee80211_hdr *hdr; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 36 | struct sk_buff *skb = tx->skb; |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 37 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 38 | int tail; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 39 | |
Harvey Harrison | c34498b | 2008-07-02 16:30:52 -0700 | [diff] [blame] | 40 | hdr = (struct ieee80211_hdr *)skb->data; |
Johannes Berg | 97359d1 | 2010-08-10 09:46:38 +0200 | [diff] [blame] | 41 | if (!tx->key || tx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP || |
| 42 | skb->len < 24 || !ieee80211_is_data_present(hdr->frame_control)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 43 | return TX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 44 | |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 45 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 46 | if (skb->len < hdrlen) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 47 | return TX_DROP; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 48 | |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 49 | data = skb->data + hdrlen; |
| 50 | data_len = skb->len - hdrlen; |
| 51 | |
Jouni Malinen | 681d119 | 2011-02-03 18:35:19 +0200 | [diff] [blame] | 52 | if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE)) { |
| 53 | /* Need to use software crypto for the test */ |
| 54 | info->control.hw_key = NULL; |
| 55 | } |
| 56 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 57 | if (info->control.hw_key && |
Johannes Berg | a26eb27 | 2011-10-07 14:01:25 +0200 | [diff] [blame] | 58 | (info->flags & IEEE80211_TX_CTL_DONTFRAG || |
| 59 | tx->local->ops->set_frag_threshold) && |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 60 | !(tx->key->conf.flags & IEEE80211_KEY_FLAG_GENERATE_MMIC)) { |
| 61 | /* hwaccel - with no need for SW-generated MMIC */ |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 62 | return TX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 63 | } |
| 64 | |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 65 | tail = MICHAEL_MIC_LEN; |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 66 | if (!info->control.hw_key) |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 67 | tail += IEEE80211_TKIP_ICV_LEN; |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 68 | |
Johannes Berg | b1e9be8 | 2014-09-08 11:22:42 +0200 | [diff] [blame] | 69 | if (WARN(skb_tailroom(skb) < tail || |
| 70 | skb_headroom(skb) < IEEE80211_TKIP_IV_LEN, |
| 71 | "mmic: not enough head/tail (%d/%d,%d/%d)\n", |
| 72 | skb_headroom(skb), IEEE80211_TKIP_IV_LEN, |
| 73 | skb_tailroom(skb), tail)) |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 74 | return TX_DROP; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 75 | |
Jouni Malinen | 747d753 | 2011-02-03 18:34:28 +0200 | [diff] [blame] | 76 | key = &tx->key->conf.key[NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY]; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 77 | mic = skb_put(skb, MICHAEL_MIC_LEN); |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 78 | michael_mic(key, hdr, data, data_len, mic); |
Jouni Malinen | 681d119 | 2011-02-03 18:35:19 +0200 | [diff] [blame] | 79 | if (unlikely(info->flags & IEEE80211_TX_INTFL_TKIP_MIC_FAILURE)) |
| 80 | mic[0]++; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 81 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 82 | return TX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 86 | ieee80211_rx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 87 | ieee80211_rx_h_michael_mic_verify(struct ieee80211_rx_data *rx) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 88 | { |
Jouni Malinen | 747d753 | 2011-02-03 18:34:28 +0200 | [diff] [blame] | 89 | u8 *data, *key = NULL; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 90 | size_t data_len; |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 91 | unsigned int hdrlen; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 92 | u8 mic[MICHAEL_MIC_LEN]; |
| 93 | struct sk_buff *skb = rx->skb; |
Johannes Berg | eb9fb5b | 2009-11-16 13:58:20 +0100 | [diff] [blame] | 94 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
| 95 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 96 | |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 97 | /* |
| 98 | * it makes no sense to check for MIC errors on anything other |
| 99 | * than data frames. |
| 100 | */ |
| 101 | if (!ieee80211_is_data_present(hdr->frame_control)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 102 | return RX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 103 | |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 104 | /* |
| 105 | * No way to verify the MIC if the hardware stripped it or |
| 106 | * the IV with the key index. In this case we have solely rely |
| 107 | * on the driver to set RX_FLAG_MMIC_ERROR in the event of a |
| 108 | * MIC failure report. |
| 109 | */ |
| 110 | if (status->flag & (RX_FLAG_MMIC_STRIPPED | RX_FLAG_IV_STRIPPED)) { |
| 111 | if (status->flag & RX_FLAG_MMIC_ERROR) |
Saravana | b98ea05 | 2012-12-04 19:47:42 +0530 | [diff] [blame] | 112 | goto mic_fail_no_key; |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 113 | |
Stanislaw Gruszka | 4045f72 | 2012-10-02 21:34:23 +0200 | [diff] [blame] | 114 | if (!(status->flag & RX_FLAG_IV_STRIPPED) && rx->key && |
| 115 | rx->key->conf.cipher == WLAN_CIPHER_SUITE_TKIP) |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 116 | goto update_iv; |
| 117 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 118 | return RX_CONTINUE; |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 119 | } |
| 120 | |
| 121 | /* |
| 122 | * Some hardware seems to generate Michael MIC failure reports; even |
| 123 | * though, the frame was not encrypted with TKIP and therefore has no |
| 124 | * MIC. Ignore the flag them to avoid triggering countermeasures. |
| 125 | */ |
| 126 | if (!rx->key || rx->key->conf.cipher != WLAN_CIPHER_SUITE_TKIP || |
| 127 | !(status->flag & RX_FLAG_DECRYPTED)) |
| 128 | return RX_CONTINUE; |
| 129 | |
| 130 | if (rx->sdata->vif.type == NL80211_IFTYPE_AP && rx->key->conf.keyidx) { |
| 131 | /* |
| 132 | * APs with pairwise keys should never receive Michael MIC |
| 133 | * errors for non-zero keyidx because these are reserved for |
| 134 | * group keys and only the AP is sending real multicast |
Emmanuel Grumbach | 87ee475 | 2014-01-07 13:09:38 +0200 | [diff] [blame] | 135 | * frames in the BSS. |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 136 | */ |
| 137 | return RX_DROP_UNUSABLE; |
| 138 | } |
| 139 | |
| 140 | if (status->flag & RX_FLAG_MMIC_ERROR) |
| 141 | goto mic_fail; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 142 | |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 143 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 144 | if (skb->len < hdrlen + MICHAEL_MIC_LEN) |
Johannes Berg | e4c26ad | 2008-01-31 19:48:21 +0100 | [diff] [blame] | 145 | return RX_DROP_UNUSABLE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 146 | |
Johannes Berg | a828691 | 2012-03-12 13:49:14 +0100 | [diff] [blame] | 147 | if (skb_linearize(rx->skb)) |
| 148 | return RX_DROP_UNUSABLE; |
| 149 | hdr = (void *)skb->data; |
| 150 | |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 151 | data = skb->data + hdrlen; |
| 152 | data_len = skb->len - hdrlen - MICHAEL_MIC_LEN; |
Jouni Malinen | 747d753 | 2011-02-03 18:34:28 +0200 | [diff] [blame] | 153 | key = &rx->key->conf.key[NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY]; |
Harvey Harrison | 8e8862b | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 154 | michael_mic(key, hdr, data, data_len, mic); |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 155 | if (memcmp(mic, data + data_len, MICHAEL_MIC_LEN) != 0) |
| 156 | goto mic_fail; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 157 | |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 158 | /* remove Michael MIC from payload */ |
| 159 | skb_trim(skb, skb->len - MICHAEL_MIC_LEN); |
| 160 | |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 161 | update_iv: |
Johannes Berg | 50741ae | 2007-09-26 15:19:45 +0200 | [diff] [blame] | 162 | /* update IV in key information to be able to detect replays */ |
Johannes Berg | 9e26297 | 2011-07-07 18:45:03 +0200 | [diff] [blame] | 163 | rx->key->u.tkip.rx[rx->security_idx].iv32 = rx->tkip_iv32; |
| 164 | rx->key->u.tkip.rx[rx->security_idx].iv16 = rx->tkip_iv16; |
Johannes Berg | 50741ae | 2007-09-26 15:19:45 +0200 | [diff] [blame] | 165 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 166 | return RX_CONTINUE; |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 167 | |
| 168 | mic_fail: |
Saravana | b98ea05 | 2012-12-04 19:47:42 +0530 | [diff] [blame] | 169 | rx->key->u.tkip.mic_failures++; |
| 170 | |
| 171 | mic_fail_no_key: |
Arik Nemtsov | a66b98d | 2011-06-23 00:00:24 +0300 | [diff] [blame] | 172 | /* |
| 173 | * In some cases the key can be unset - e.g. a multicast packet, in |
| 174 | * a driver that supports HW encryption. Send up the key idx only if |
| 175 | * the key is set. |
| 176 | */ |
| 177 | mac80211_ev_michael_mic_failure(rx->sdata, |
| 178 | rx->key ? rx->key->conf.keyidx : -1, |
Christian Lamparter | 816c04f | 2011-04-30 15:24:30 +0200 | [diff] [blame] | 179 | (void *) skb->data, NULL, GFP_ATOMIC); |
| 180 | return RX_DROP_UNUSABLE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 181 | } |
| 182 | |
| 183 | |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 184 | static int tkip_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 185 | { |
| 186 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; |
| 187 | struct ieee80211_key *key = tx->key; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 188 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Harvey Harrison | d5184ca | 2008-06-11 14:21:58 -0700 | [diff] [blame] | 189 | unsigned int hdrlen; |
| 190 | int len, tail; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 191 | u8 *pos; |
| 192 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 193 | if (info->control.hw_key && |
Janusz.Dziedzic@tieto.com | ee70108 | 2012-05-09 08:11:20 +0300 | [diff] [blame] | 194 | !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) && |
| 195 | !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) { |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 196 | /* hwaccel - with no need for software-generated IV */ |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 197 | return 0; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 198 | } |
| 199 | |
Harvey Harrison | d5184ca | 2008-06-11 14:21:58 -0700 | [diff] [blame] | 200 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 201 | len = skb->len - hdrlen; |
| 202 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 203 | if (info->control.hw_key) |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 204 | tail = 0; |
Johannes Berg | 11a843b | 2007-08-28 17:01:55 -0400 | [diff] [blame] | 205 | else |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 206 | tail = IEEE80211_TKIP_ICV_LEN; |
Johannes Berg | 8f20fc2 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 207 | |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 208 | if (WARN_ON(skb_tailroom(skb) < tail || |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 209 | skb_headroom(skb) < IEEE80211_TKIP_IV_LEN)) |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 210 | return -1; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 211 | |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 212 | pos = skb_push(skb, IEEE80211_TKIP_IV_LEN); |
| 213 | memmove(pos, pos + IEEE80211_TKIP_IV_LEN, hdrlen); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 214 | pos += hdrlen; |
| 215 | |
Janusz.Dziedzic@tieto.com | ee70108 | 2012-05-09 08:11:20 +0300 | [diff] [blame] | 216 | /* the HW only needs room for the IV, but not the actual IV */ |
| 217 | if (info->control.hw_key && |
| 218 | (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) |
| 219 | return 0; |
| 220 | |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 221 | /* Increase IV for the frame */ |
Johannes Berg | 0339500 | 2013-02-13 18:03:00 +0100 | [diff] [blame] | 222 | spin_lock(&key->u.tkip.txlock); |
Harvey Harrison | b0f76b3 | 2008-05-14 16:26:19 -0700 | [diff] [blame] | 223 | key->u.tkip.tx.iv16++; |
| 224 | if (key->u.tkip.tx.iv16 == 0) |
| 225 | key->u.tkip.tx.iv32++; |
Johannes Berg | 523b02e | 2011-07-07 22:28:01 +0200 | [diff] [blame] | 226 | pos = ieee80211_tkip_add_iv(pos, key); |
Johannes Berg | 0339500 | 2013-02-13 18:03:00 +0100 | [diff] [blame] | 227 | spin_unlock(&key->u.tkip.txlock); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 228 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 229 | /* hwaccel - with software IV */ |
| 230 | if (info->control.hw_key) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 231 | return 0; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 232 | |
| 233 | /* Add room for ICV */ |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 234 | skb_put(skb, IEEE80211_TKIP_ICV_LEN); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 235 | |
John W. Linville | 3473187 | 2010-07-07 15:07:49 -0400 | [diff] [blame] | 236 | return ieee80211_tkip_encrypt_data(tx->local->wep_tx_tfm, |
Johannes Berg | 523b02e | 2011-07-07 22:28:01 +0200 | [diff] [blame] | 237 | key, skb, pos, len); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 241 | ieee80211_tx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 242 | ieee80211_crypto_tkip_encrypt(struct ieee80211_tx_data *tx) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 243 | { |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 244 | struct sk_buff *skb; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 245 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 246 | ieee80211_tx_set_protected(tx); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 247 | |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 248 | skb_queue_walk(&tx->skbs, skb) { |
Johannes Berg | 2de8e0d | 2009-03-23 17:28:35 +0100 | [diff] [blame] | 249 | if (tkip_encrypt_skb(tx, skb) < 0) |
| 250 | return TX_DROP; |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 251 | } |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 252 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 253 | return TX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 257 | ieee80211_rx_result |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 258 | ieee80211_crypto_tkip_decrypt(struct ieee80211_rx_data *rx) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 259 | { |
| 260 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) rx->skb->data; |
Jouni Malinen | 747d753 | 2011-02-03 18:34:28 +0200 | [diff] [blame] | 261 | int hdrlen, res, hwaccel = 0; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 262 | struct ieee80211_key *key = rx->key; |
| 263 | struct sk_buff *skb = rx->skb; |
Johannes Berg | eb9fb5b | 2009-11-16 13:58:20 +0100 | [diff] [blame] | 264 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 265 | |
Harvey Harrison | d5184ca | 2008-06-11 14:21:58 -0700 | [diff] [blame] | 266 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 267 | |
Harvey Harrison | c34498b | 2008-07-02 16:30:52 -0700 | [diff] [blame] | 268 | if (!ieee80211_is_data(hdr->frame_control)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 269 | return RX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 270 | |
| 271 | if (!rx->sta || skb->len - hdrlen < 12) |
Johannes Berg | e4c26ad | 2008-01-31 19:48:21 +0100 | [diff] [blame] | 272 | return RX_DROP_UNUSABLE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 273 | |
Johannes Berg | a828691 | 2012-03-12 13:49:14 +0100 | [diff] [blame] | 274 | /* it may be possible to optimize this a bit more */ |
| 275 | if (skb_linearize(rx->skb)) |
| 276 | return RX_DROP_UNUSABLE; |
| 277 | hdr = (void *)skb->data; |
| 278 | |
Johannes Berg | dc1580d | 2010-08-10 09:46:40 +0200 | [diff] [blame] | 279 | /* |
| 280 | * Let TKIP code verify IV, but skip decryption. |
| 281 | * In the case where hardware checks the IV as well, |
| 282 | * we don't even get here, see ieee80211_rx_h_decrypt() |
| 283 | */ |
| 284 | if (status->flag & RX_FLAG_DECRYPTED) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 285 | hwaccel = 1; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 286 | |
| 287 | res = ieee80211_tkip_decrypt_data(rx->local->wep_rx_tfm, |
| 288 | key, skb->data + hdrlen, |
Johannes Berg | 17741cd | 2008-09-11 00:02:02 +0200 | [diff] [blame] | 289 | skb->len - hdrlen, rx->sta->sta.addr, |
Johannes Berg | 9e26297 | 2011-07-07 18:45:03 +0200 | [diff] [blame] | 290 | hdr->addr1, hwaccel, rx->security_idx, |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 291 | &rx->tkip_iv32, |
| 292 | &rx->tkip_iv16); |
Jouni Malinen | 747d753 | 2011-02-03 18:34:28 +0200 | [diff] [blame] | 293 | if (res != TKIP_DECRYPT_OK) |
Johannes Berg | e4c26ad | 2008-01-31 19:48:21 +0100 | [diff] [blame] | 294 | return RX_DROP_UNUSABLE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 295 | |
| 296 | /* Trim ICV */ |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 297 | skb_trim(skb, skb->len - IEEE80211_TKIP_ICV_LEN); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 298 | |
| 299 | /* Remove IV */ |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 300 | memmove(skb->data + IEEE80211_TKIP_IV_LEN, skb->data, hdrlen); |
| 301 | skb_pull(skb, IEEE80211_TKIP_IV_LEN); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 302 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 303 | return RX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | |
Ard Biesheuvel | 30ef7ef | 2014-01-16 12:16:30 +0100 | [diff] [blame] | 307 | static void ccmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *b_0, u8 *aad) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 308 | { |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 309 | __le16 mask_fc; |
Jouni Malinen | fb73333 | 2009-01-08 13:32:00 +0200 | [diff] [blame] | 310 | int a4_included, mgmt; |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 311 | u8 qos_tid; |
Ard Biesheuvel | 7ec7c4a | 2013-10-10 09:55:20 +0200 | [diff] [blame] | 312 | u16 len_a; |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 313 | unsigned int hdrlen; |
| 314 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 315 | |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 316 | /* |
Jouni Malinen | fb73333 | 2009-01-08 13:32:00 +0200 | [diff] [blame] | 317 | * Mask FC: zero subtype b4 b5 b6 (if not mgmt) |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 318 | * Retry, PwrMgt, MoreData; set Protected |
| 319 | */ |
Jouni Malinen | fb73333 | 2009-01-08 13:32:00 +0200 | [diff] [blame] | 320 | mgmt = ieee80211_is_mgmt(hdr->frame_control); |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 321 | mask_fc = hdr->frame_control; |
Jouni Malinen | fb73333 | 2009-01-08 13:32:00 +0200 | [diff] [blame] | 322 | mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY | |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 323 | IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA); |
Jouni Malinen | fb73333 | 2009-01-08 13:32:00 +0200 | [diff] [blame] | 324 | if (!mgmt) |
| 325 | mask_fc &= ~cpu_to_le16(0x0070); |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 326 | mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 327 | |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 328 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 329 | len_a = hdrlen - 2; |
| 330 | a4_included = ieee80211_has_a4(hdr->frame_control); |
| 331 | |
| 332 | if (ieee80211_is_data_qos(hdr->frame_control)) |
| 333 | qos_tid = *ieee80211_get_qos_ctl(hdr) & IEEE80211_QOS_CTL_TID_MASK; |
| 334 | else |
| 335 | qos_tid = 0; |
| 336 | |
Ard Biesheuvel | 7ec7c4a | 2013-10-10 09:55:20 +0200 | [diff] [blame] | 337 | /* In CCM, the initial vectors (IV) used for CTR mode encryption and CBC |
| 338 | * mode authentication are not allowed to collide, yet both are derived |
| 339 | * from this vector b_0. We only set L := 1 here to indicate that the |
| 340 | * data size can be represented in (L+1) bytes. The CCM layer will take |
| 341 | * care of storing the data length in the top (L+1) bytes and setting |
| 342 | * and clearing the other bits as is required to derive the two IVs. |
| 343 | */ |
| 344 | b_0[0] = 0x1; |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 345 | |
Jouni Malinen | fb73333 | 2009-01-08 13:32:00 +0200 | [diff] [blame] | 346 | /* Nonce: Nonce Flags | A2 | PN |
| 347 | * Nonce Flags: Priority (b0..b3) | Management (b4) | Reserved (b5..b7) |
| 348 | */ |
| 349 | b_0[1] = qos_tid | (mgmt << 4); |
Harvey Harrison | 73e1f7c | 2008-07-02 11:05:34 -0700 | [diff] [blame] | 350 | memcpy(&b_0[2], hdr->addr2, ETH_ALEN); |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 351 | memcpy(&b_0[8], pn, IEEE80211_CCMP_PN_LEN); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 352 | |
| 353 | /* AAD (extra authenticate-only data) / masked 802.11 header |
| 354 | * FC | A1 | A2 | A3 | SC | [A4] | [QC] */ |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 355 | put_unaligned_be16(len_a, &aad[0]); |
| 356 | put_unaligned(mask_fc, (__le16 *)&aad[2]); |
Harvey Harrison | 73e1f7c | 2008-07-02 11:05:34 -0700 | [diff] [blame] | 357 | memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 358 | |
| 359 | /* Mask Seq#, leave Frag# */ |
| 360 | aad[22] = *((u8 *) &hdr->seq_ctrl) & 0x0f; |
| 361 | aad[23] = 0; |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 362 | |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 363 | if (a4_included) { |
Harvey Harrison | 73e1f7c | 2008-07-02 11:05:34 -0700 | [diff] [blame] | 364 | memcpy(&aad[24], hdr->addr4, ETH_ALEN); |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 365 | aad[30] = qos_tid; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 366 | aad[31] = 0; |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 367 | } else { |
Harvey Harrison | 73e1f7c | 2008-07-02 11:05:34 -0700 | [diff] [blame] | 368 | memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN); |
Harvey Harrison | f14df80 | 2008-07-02 11:05:35 -0700 | [diff] [blame] | 369 | aad[24] = qos_tid; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 370 | } |
| 371 | } |
| 372 | |
| 373 | |
| 374 | static inline void ccmp_pn2hdr(u8 *hdr, u8 *pn, int key_id) |
| 375 | { |
| 376 | hdr[0] = pn[5]; |
| 377 | hdr[1] = pn[4]; |
| 378 | hdr[2] = 0; |
| 379 | hdr[3] = 0x20 | (key_id << 6); |
| 380 | hdr[4] = pn[3]; |
| 381 | hdr[5] = pn[2]; |
| 382 | hdr[6] = pn[1]; |
| 383 | hdr[7] = pn[0]; |
| 384 | } |
| 385 | |
| 386 | |
Johannes Berg | c6a1fa1 | 2008-10-07 12:04:32 +0200 | [diff] [blame] | 387 | static inline void ccmp_hdr2pn(u8 *pn, u8 *hdr) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 388 | { |
| 389 | pn[0] = hdr[7]; |
| 390 | pn[1] = hdr[6]; |
| 391 | pn[2] = hdr[5]; |
| 392 | pn[3] = hdr[4]; |
| 393 | pn[4] = hdr[1]; |
| 394 | pn[5] = hdr[0]; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 395 | } |
| 396 | |
| 397 | |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 398 | static int ccmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb, |
| 399 | unsigned int mic_len) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 400 | { |
| 401 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; |
| 402 | struct ieee80211_key *key = tx->key; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 403 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 404 | int hdrlen, len, tail; |
Johannes Berg | aba83a0b | 2011-07-06 21:59:39 +0200 | [diff] [blame] | 405 | u8 *pos; |
| 406 | u8 pn[6]; |
| 407 | u64 pn64; |
Ard Biesheuvel | 7ec7c4a | 2013-10-10 09:55:20 +0200 | [diff] [blame] | 408 | u8 aad[2 * AES_BLOCK_SIZE]; |
| 409 | u8 b_0[AES_BLOCK_SIZE]; |
Jouni Malinen | 1f7d77a | 2009-01-08 13:32:10 +0200 | [diff] [blame] | 410 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 411 | if (info->control.hw_key && |
Arik Nemtsov | 077a915 | 2011-10-23 08:21:41 +0200 | [diff] [blame] | 412 | !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) && |
Marek Kwaczynski | 17d38fa | 2014-04-14 11:27:21 +0200 | [diff] [blame] | 413 | !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) && |
| 414 | !((info->control.hw_key->flags & |
| 415 | IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) && |
| 416 | ieee80211_is_mgmt(hdr->frame_control))) { |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 417 | /* |
| 418 | * hwaccel has no need for preallocated room for CCMP |
| 419 | * header or MIC fields |
| 420 | */ |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 421 | return 0; |
Johannes Berg | e039fa4 | 2008-05-15 12:55:29 +0200 | [diff] [blame] | 422 | } |
| 423 | |
Harvey Harrison | d5184ca | 2008-06-11 14:21:58 -0700 | [diff] [blame] | 424 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 425 | len = skb->len - hdrlen; |
| 426 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 427 | if (info->control.hw_key) |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 428 | tail = 0; |
Johannes Berg | 11a843b | 2007-08-28 17:01:55 -0400 | [diff] [blame] | 429 | else |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 430 | tail = mic_len; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 431 | |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 432 | if (WARN_ON(skb_tailroom(skb) < tail || |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 433 | skb_headroom(skb) < IEEE80211_CCMP_HDR_LEN)) |
Johannes Berg | 23c0752 | 2008-05-29 10:38:53 +0200 | [diff] [blame] | 434 | return -1; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 435 | |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 436 | pos = skb_push(skb, IEEE80211_CCMP_HDR_LEN); |
| 437 | memmove(pos, pos + IEEE80211_CCMP_HDR_LEN, hdrlen); |
Arik Nemtsov | 077a915 | 2011-10-23 08:21:41 +0200 | [diff] [blame] | 438 | |
| 439 | /* the HW only needs room for the IV, but not the actual IV */ |
Arik Nemtsov | e0830f7 | 2011-11-10 09:35:13 +0200 | [diff] [blame] | 440 | if (info->control.hw_key && |
| 441 | (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) |
Arik Nemtsov | 077a915 | 2011-10-23 08:21:41 +0200 | [diff] [blame] | 442 | return 0; |
| 443 | |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 444 | hdr = (struct ieee80211_hdr *) pos; |
| 445 | pos += hdrlen; |
| 446 | |
Johannes Berg | aba83a0b | 2011-07-06 21:59:39 +0200 | [diff] [blame] | 447 | pn64 = atomic64_inc_return(&key->u.ccmp.tx_pn); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 448 | |
Johannes Berg | aba83a0b | 2011-07-06 21:59:39 +0200 | [diff] [blame] | 449 | pn[5] = pn64; |
| 450 | pn[4] = pn64 >> 8; |
| 451 | pn[3] = pn64 >> 16; |
| 452 | pn[2] = pn64 >> 24; |
| 453 | pn[1] = pn64 >> 32; |
| 454 | pn[0] = pn64 >> 40; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 455 | |
Johannes Berg | 8f20fc2 | 2007-08-28 17:01:54 -0400 | [diff] [blame] | 456 | ccmp_pn2hdr(pos, pn, key->conf.keyidx); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 457 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 458 | /* hwaccel - with software CCMP header */ |
| 459 | if (info->control.hw_key) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 460 | return 0; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 461 | |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 462 | pos += IEEE80211_CCMP_HDR_LEN; |
Ard Biesheuvel | 30ef7ef | 2014-01-16 12:16:30 +0100 | [diff] [blame] | 463 | ccmp_special_blocks(skb, pn, b_0, aad); |
Ard Biesheuvel | 7ec7c4a | 2013-10-10 09:55:20 +0200 | [diff] [blame] | 464 | ieee80211_aes_ccm_encrypt(key->u.ccmp.tfm, b_0, aad, pos, len, |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 465 | skb_put(skb, mic_len), mic_len); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 466 | |
| 467 | return 0; |
| 468 | } |
| 469 | |
| 470 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 471 | ieee80211_tx_result |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 472 | ieee80211_crypto_ccmp_encrypt(struct ieee80211_tx_data *tx, |
| 473 | unsigned int mic_len) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 474 | { |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 475 | struct sk_buff *skb; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 476 | |
Johannes Berg | 5cf121c | 2008-02-25 16:27:43 +0100 | [diff] [blame] | 477 | ieee80211_tx_set_protected(tx); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 478 | |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 479 | skb_queue_walk(&tx->skbs, skb) { |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 480 | if (ccmp_encrypt_skb(tx, skb, mic_len) < 0) |
Johannes Berg | 2de8e0d | 2009-03-23 17:28:35 +0100 | [diff] [blame] | 481 | return TX_DROP; |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 482 | } |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 483 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 484 | return TX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 485 | } |
| 486 | |
| 487 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 488 | ieee80211_rx_result |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 489 | ieee80211_crypto_ccmp_decrypt(struct ieee80211_rx_data *rx, |
| 490 | unsigned int mic_len) |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 491 | { |
Harvey Harrison | c34498b | 2008-07-02 16:30:52 -0700 | [diff] [blame] | 492 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 493 | int hdrlen; |
| 494 | struct ieee80211_key *key = rx->key; |
| 495 | struct sk_buff *skb = rx->skb; |
Johannes Berg | eb9fb5b | 2009-11-16 13:58:20 +0100 | [diff] [blame] | 496 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 497 | u8 pn[IEEE80211_CCMP_PN_LEN]; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 498 | int data_len; |
Jouni Malinen | 9190252 | 2010-06-11 10:27:33 -0700 | [diff] [blame] | 499 | int queue; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 500 | |
Harvey Harrison | d5184ca | 2008-06-11 14:21:58 -0700 | [diff] [blame] | 501 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 502 | |
Jouni Malinen | fb73333 | 2009-01-08 13:32:00 +0200 | [diff] [blame] | 503 | if (!ieee80211_is_data(hdr->frame_control) && |
Johannes Berg | d8ca16d | 2014-01-23 16:20:29 +0100 | [diff] [blame] | 504 | !ieee80211_is_robust_mgmt_frame(skb)) |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 505 | return RX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 506 | |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 507 | data_len = skb->len - hdrlen - IEEE80211_CCMP_HDR_LEN - mic_len; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 508 | if (!rx->sta || data_len < 0) |
Johannes Berg | e4c26ad | 2008-01-31 19:48:21 +0100 | [diff] [blame] | 509 | return RX_DROP_UNUSABLE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 510 | |
Johannes Berg | a828691 | 2012-03-12 13:49:14 +0100 | [diff] [blame] | 511 | if (status->flag & RX_FLAG_DECRYPTED) { |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 512 | if (!pskb_may_pull(rx->skb, hdrlen + IEEE80211_CCMP_HDR_LEN)) |
Johannes Berg | a828691 | 2012-03-12 13:49:14 +0100 | [diff] [blame] | 513 | return RX_DROP_UNUSABLE; |
| 514 | } else { |
| 515 | if (skb_linearize(rx->skb)) |
| 516 | return RX_DROP_UNUSABLE; |
| 517 | } |
| 518 | |
Johannes Berg | c6a1fa1 | 2008-10-07 12:04:32 +0200 | [diff] [blame] | 519 | ccmp_hdr2pn(pn, skb->data + hdrlen); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 520 | |
Johannes Berg | 9e26297 | 2011-07-07 18:45:03 +0200 | [diff] [blame] | 521 | queue = rx->security_idx; |
Jouni Malinen | 9190252 | 2010-06-11 10:27:33 -0700 | [diff] [blame] | 522 | |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 523 | if (memcmp(pn, key->u.ccmp.rx_pn[queue], IEEE80211_CCMP_PN_LEN) <= 0) { |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 524 | key->u.ccmp.replays++; |
Johannes Berg | e4c26ad | 2008-01-31 19:48:21 +0100 | [diff] [blame] | 525 | return RX_DROP_UNUSABLE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 526 | } |
| 527 | |
Johannes Berg | eb9fb5b | 2009-11-16 13:58:20 +0100 | [diff] [blame] | 528 | if (!(status->flag & RX_FLAG_DECRYPTED)) { |
Ard Biesheuvel | 7ec7c4a | 2013-10-10 09:55:20 +0200 | [diff] [blame] | 529 | u8 aad[2 * AES_BLOCK_SIZE]; |
| 530 | u8 b_0[AES_BLOCK_SIZE]; |
Johannes Berg | 7848ba7 | 2007-09-14 11:10:25 -0400 | [diff] [blame] | 531 | /* hardware didn't decrypt/verify MIC */ |
Ard Biesheuvel | 30ef7ef | 2014-01-16 12:16:30 +0100 | [diff] [blame] | 532 | ccmp_special_blocks(skb, pn, b_0, aad); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 533 | |
| 534 | if (ieee80211_aes_ccm_decrypt( |
Ard Biesheuvel | 7ec7c4a | 2013-10-10 09:55:20 +0200 | [diff] [blame] | 535 | key->u.ccmp.tfm, b_0, aad, |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 536 | skb->data + hdrlen + IEEE80211_CCMP_HDR_LEN, |
| 537 | data_len, |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 538 | skb->data + skb->len - mic_len, mic_len)) |
Johannes Berg | e4c26ad | 2008-01-31 19:48:21 +0100 | [diff] [blame] | 539 | return RX_DROP_UNUSABLE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 540 | } |
| 541 | |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 542 | memcpy(key->u.ccmp.rx_pn[queue], pn, IEEE80211_CCMP_PN_LEN); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 543 | |
| 544 | /* Remove CCMP header and MIC */ |
Jouni Malinen | 2b2ba0d | 2015-01-24 19:52:07 +0200 | [diff] [blame] | 545 | if (pskb_trim(skb, skb->len - mic_len)) |
Johannes Berg | a828691 | 2012-03-12 13:49:14 +0100 | [diff] [blame] | 546 | return RX_DROP_UNUSABLE; |
Johannes Berg | 4325f6c | 2013-05-08 13:09:08 +0200 | [diff] [blame] | 547 | memmove(skb->data + IEEE80211_CCMP_HDR_LEN, skb->data, hdrlen); |
| 548 | skb_pull(skb, IEEE80211_CCMP_HDR_LEN); |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 549 | |
Johannes Berg | 9ae54c8 | 2008-01-31 19:48:20 +0100 | [diff] [blame] | 550 | return RX_CONTINUE; |
Jiri Benc | f0706e8 | 2007-05-05 11:45:53 -0700 | [diff] [blame] | 551 | } |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 552 | |
Jouni Malinen | 00b9cfa | 2015-01-24 19:52:06 +0200 | [diff] [blame] | 553 | static void gcmp_special_blocks(struct sk_buff *skb, u8 *pn, u8 *j_0, u8 *aad) |
| 554 | { |
| 555 | __le16 mask_fc; |
| 556 | u8 qos_tid; |
| 557 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 558 | |
| 559 | memcpy(j_0, hdr->addr2, ETH_ALEN); |
| 560 | memcpy(&j_0[ETH_ALEN], pn, IEEE80211_GCMP_PN_LEN); |
| 561 | j_0[13] = 0; |
| 562 | j_0[14] = 0; |
| 563 | j_0[AES_BLOCK_SIZE - 1] = 0x01; |
| 564 | |
| 565 | /* AAD (extra authenticate-only data) / masked 802.11 header |
| 566 | * FC | A1 | A2 | A3 | SC | [A4] | [QC] |
| 567 | */ |
| 568 | put_unaligned_be16(ieee80211_hdrlen(hdr->frame_control) - 2, &aad[0]); |
| 569 | /* Mask FC: zero subtype b4 b5 b6 (if not mgmt) |
| 570 | * Retry, PwrMgt, MoreData; set Protected |
| 571 | */ |
| 572 | mask_fc = hdr->frame_control; |
| 573 | mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY | |
| 574 | IEEE80211_FCTL_PM | IEEE80211_FCTL_MOREDATA); |
| 575 | if (!ieee80211_is_mgmt(hdr->frame_control)) |
| 576 | mask_fc &= ~cpu_to_le16(0x0070); |
| 577 | mask_fc |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); |
| 578 | |
| 579 | put_unaligned(mask_fc, (__le16 *)&aad[2]); |
| 580 | memcpy(&aad[4], &hdr->addr1, 3 * ETH_ALEN); |
| 581 | |
| 582 | /* Mask Seq#, leave Frag# */ |
| 583 | aad[22] = *((u8 *)&hdr->seq_ctrl) & 0x0f; |
| 584 | aad[23] = 0; |
| 585 | |
| 586 | if (ieee80211_is_data_qos(hdr->frame_control)) |
| 587 | qos_tid = *ieee80211_get_qos_ctl(hdr) & |
| 588 | IEEE80211_QOS_CTL_TID_MASK; |
| 589 | else |
| 590 | qos_tid = 0; |
| 591 | |
| 592 | if (ieee80211_has_a4(hdr->frame_control)) { |
| 593 | memcpy(&aad[24], hdr->addr4, ETH_ALEN); |
| 594 | aad[30] = qos_tid; |
| 595 | aad[31] = 0; |
| 596 | } else { |
| 597 | memset(&aad[24], 0, ETH_ALEN + IEEE80211_QOS_CTL_LEN); |
| 598 | aad[24] = qos_tid; |
| 599 | } |
| 600 | } |
| 601 | |
| 602 | static inline void gcmp_pn2hdr(u8 *hdr, const u8 *pn, int key_id) |
| 603 | { |
| 604 | hdr[0] = pn[5]; |
| 605 | hdr[1] = pn[4]; |
| 606 | hdr[2] = 0; |
| 607 | hdr[3] = 0x20 | (key_id << 6); |
| 608 | hdr[4] = pn[3]; |
| 609 | hdr[5] = pn[2]; |
| 610 | hdr[6] = pn[1]; |
| 611 | hdr[7] = pn[0]; |
| 612 | } |
| 613 | |
| 614 | static inline void gcmp_hdr2pn(u8 *pn, const u8 *hdr) |
| 615 | { |
| 616 | pn[0] = hdr[7]; |
| 617 | pn[1] = hdr[6]; |
| 618 | pn[2] = hdr[5]; |
| 619 | pn[3] = hdr[4]; |
| 620 | pn[4] = hdr[1]; |
| 621 | pn[5] = hdr[0]; |
| 622 | } |
| 623 | |
| 624 | static int gcmp_encrypt_skb(struct ieee80211_tx_data *tx, struct sk_buff *skb) |
| 625 | { |
| 626 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 627 | struct ieee80211_key *key = tx->key; |
| 628 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
| 629 | int hdrlen, len, tail; |
| 630 | u8 *pos; |
| 631 | u8 pn[6]; |
| 632 | u64 pn64; |
| 633 | u8 aad[2 * AES_BLOCK_SIZE]; |
| 634 | u8 j_0[AES_BLOCK_SIZE]; |
| 635 | |
| 636 | if (info->control.hw_key && |
| 637 | !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_GENERATE_IV) && |
| 638 | !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE) && |
| 639 | !((info->control.hw_key->flags & |
| 640 | IEEE80211_KEY_FLAG_GENERATE_IV_MGMT) && |
| 641 | ieee80211_is_mgmt(hdr->frame_control))) { |
| 642 | /* hwaccel has no need for preallocated room for GCMP |
| 643 | * header or MIC fields |
| 644 | */ |
| 645 | return 0; |
| 646 | } |
| 647 | |
| 648 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 649 | len = skb->len - hdrlen; |
| 650 | |
| 651 | if (info->control.hw_key) |
| 652 | tail = 0; |
| 653 | else |
| 654 | tail = IEEE80211_GCMP_MIC_LEN; |
| 655 | |
| 656 | if (WARN_ON(skb_tailroom(skb) < tail || |
| 657 | skb_headroom(skb) < IEEE80211_GCMP_HDR_LEN)) |
| 658 | return -1; |
| 659 | |
| 660 | pos = skb_push(skb, IEEE80211_GCMP_HDR_LEN); |
| 661 | memmove(pos, pos + IEEE80211_GCMP_HDR_LEN, hdrlen); |
| 662 | skb_set_network_header(skb, skb_network_offset(skb) + |
| 663 | IEEE80211_GCMP_HDR_LEN); |
| 664 | |
| 665 | /* the HW only needs room for the IV, but not the actual IV */ |
| 666 | if (info->control.hw_key && |
| 667 | (info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) |
| 668 | return 0; |
| 669 | |
| 670 | hdr = (struct ieee80211_hdr *)pos; |
| 671 | pos += hdrlen; |
| 672 | |
| 673 | pn64 = atomic64_inc_return(&key->u.gcmp.tx_pn); |
| 674 | |
| 675 | pn[5] = pn64; |
| 676 | pn[4] = pn64 >> 8; |
| 677 | pn[3] = pn64 >> 16; |
| 678 | pn[2] = pn64 >> 24; |
| 679 | pn[1] = pn64 >> 32; |
| 680 | pn[0] = pn64 >> 40; |
| 681 | |
| 682 | gcmp_pn2hdr(pos, pn, key->conf.keyidx); |
| 683 | |
| 684 | /* hwaccel - with software GCMP header */ |
| 685 | if (info->control.hw_key) |
| 686 | return 0; |
| 687 | |
| 688 | pos += IEEE80211_GCMP_HDR_LEN; |
| 689 | gcmp_special_blocks(skb, pn, j_0, aad); |
| 690 | ieee80211_aes_gcm_encrypt(key->u.gcmp.tfm, j_0, aad, pos, len, |
| 691 | skb_put(skb, IEEE80211_GCMP_MIC_LEN)); |
| 692 | |
| 693 | return 0; |
| 694 | } |
| 695 | |
| 696 | ieee80211_tx_result |
| 697 | ieee80211_crypto_gcmp_encrypt(struct ieee80211_tx_data *tx) |
| 698 | { |
| 699 | struct sk_buff *skb; |
| 700 | |
| 701 | ieee80211_tx_set_protected(tx); |
| 702 | |
| 703 | skb_queue_walk(&tx->skbs, skb) { |
| 704 | if (gcmp_encrypt_skb(tx, skb) < 0) |
| 705 | return TX_DROP; |
| 706 | } |
| 707 | |
| 708 | return TX_CONTINUE; |
| 709 | } |
| 710 | |
| 711 | ieee80211_rx_result |
| 712 | ieee80211_crypto_gcmp_decrypt(struct ieee80211_rx_data *rx) |
| 713 | { |
| 714 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; |
| 715 | int hdrlen; |
| 716 | struct ieee80211_key *key = rx->key; |
| 717 | struct sk_buff *skb = rx->skb; |
| 718 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
| 719 | u8 pn[IEEE80211_GCMP_PN_LEN]; |
| 720 | int data_len; |
| 721 | int queue; |
| 722 | |
| 723 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 724 | |
| 725 | if (!ieee80211_is_data(hdr->frame_control) && |
| 726 | !ieee80211_is_robust_mgmt_frame(skb)) |
| 727 | return RX_CONTINUE; |
| 728 | |
| 729 | data_len = skb->len - hdrlen - IEEE80211_GCMP_HDR_LEN - |
| 730 | IEEE80211_GCMP_MIC_LEN; |
| 731 | if (!rx->sta || data_len < 0) |
| 732 | return RX_DROP_UNUSABLE; |
| 733 | |
| 734 | if (status->flag & RX_FLAG_DECRYPTED) { |
| 735 | if (!pskb_may_pull(rx->skb, hdrlen + IEEE80211_GCMP_HDR_LEN)) |
| 736 | return RX_DROP_UNUSABLE; |
| 737 | } else { |
| 738 | if (skb_linearize(rx->skb)) |
| 739 | return RX_DROP_UNUSABLE; |
| 740 | } |
| 741 | |
| 742 | gcmp_hdr2pn(pn, skb->data + hdrlen); |
| 743 | |
| 744 | queue = rx->security_idx; |
| 745 | |
| 746 | if (memcmp(pn, key->u.gcmp.rx_pn[queue], IEEE80211_GCMP_PN_LEN) <= 0) { |
| 747 | key->u.gcmp.replays++; |
| 748 | return RX_DROP_UNUSABLE; |
| 749 | } |
| 750 | |
| 751 | if (!(status->flag & RX_FLAG_DECRYPTED)) { |
| 752 | u8 aad[2 * AES_BLOCK_SIZE]; |
| 753 | u8 j_0[AES_BLOCK_SIZE]; |
| 754 | /* hardware didn't decrypt/verify MIC */ |
| 755 | gcmp_special_blocks(skb, pn, j_0, aad); |
| 756 | |
| 757 | if (ieee80211_aes_gcm_decrypt( |
| 758 | key->u.gcmp.tfm, j_0, aad, |
| 759 | skb->data + hdrlen + IEEE80211_GCMP_HDR_LEN, |
| 760 | data_len, |
| 761 | skb->data + skb->len - IEEE80211_GCMP_MIC_LEN)) |
| 762 | return RX_DROP_UNUSABLE; |
| 763 | } |
| 764 | |
| 765 | memcpy(key->u.gcmp.rx_pn[queue], pn, IEEE80211_GCMP_PN_LEN); |
| 766 | |
| 767 | /* Remove GCMP header and MIC */ |
| 768 | if (pskb_trim(skb, skb->len - IEEE80211_GCMP_MIC_LEN)) |
| 769 | return RX_DROP_UNUSABLE; |
| 770 | memmove(skb->data + IEEE80211_GCMP_HDR_LEN, skb->data, hdrlen); |
| 771 | skb_pull(skb, IEEE80211_GCMP_HDR_LEN); |
| 772 | |
| 773 | return RX_CONTINUE; |
| 774 | } |
| 775 | |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 776 | static ieee80211_tx_result |
| 777 | ieee80211_crypto_cs_encrypt(struct ieee80211_tx_data *tx, |
| 778 | struct sk_buff *skb) |
| 779 | { |
| 780 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 781 | struct ieee80211_key *key = tx->key; |
| 782 | struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 783 | int hdrlen; |
Cedric Izoard | c7ef38e | 2015-03-17 10:47:33 +0000 | [diff] [blame] | 784 | u8 *pos, iv_len = key->conf.iv_len; |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 785 | |
| 786 | if (info->control.hw_key && |
| 787 | !(info->control.hw_key->flags & IEEE80211_KEY_FLAG_PUT_IV_SPACE)) { |
| 788 | /* hwaccel has no need for preallocated head room */ |
| 789 | return TX_CONTINUE; |
| 790 | } |
| 791 | |
Cedric Izoard | c7ef38e | 2015-03-17 10:47:33 +0000 | [diff] [blame] | 792 | if (unlikely(skb_headroom(skb) < iv_len && |
| 793 | pskb_expand_head(skb, iv_len, 0, GFP_ATOMIC))) |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 794 | return TX_DROP; |
| 795 | |
| 796 | hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 797 | |
Cedric Izoard | c7ef38e | 2015-03-17 10:47:33 +0000 | [diff] [blame] | 798 | pos = skb_push(skb, iv_len); |
| 799 | memmove(pos, pos + iv_len, hdrlen); |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 800 | |
| 801 | return TX_CONTINUE; |
| 802 | } |
| 803 | |
| 804 | static inline int ieee80211_crypto_cs_pn_compare(u8 *pn1, u8 *pn2, int len) |
| 805 | { |
| 806 | int i; |
| 807 | |
| 808 | /* pn is little endian */ |
| 809 | for (i = len - 1; i >= 0; i--) { |
| 810 | if (pn1[i] < pn2[i]) |
| 811 | return -1; |
| 812 | else if (pn1[i] > pn2[i]) |
| 813 | return 1; |
| 814 | } |
| 815 | |
| 816 | return 0; |
| 817 | } |
| 818 | |
| 819 | static ieee80211_rx_result |
| 820 | ieee80211_crypto_cs_decrypt(struct ieee80211_rx_data *rx) |
| 821 | { |
| 822 | struct ieee80211_key *key = rx->key; |
| 823 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; |
| 824 | const struct ieee80211_cipher_scheme *cs = NULL; |
| 825 | int hdrlen = ieee80211_hdrlen(hdr->frame_control); |
| 826 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(rx->skb); |
| 827 | int data_len; |
| 828 | u8 *rx_pn; |
| 829 | u8 *skb_pn; |
| 830 | u8 qos_tid; |
| 831 | |
| 832 | if (!rx->sta || !rx->sta->cipher_scheme || |
| 833 | !(status->flag & RX_FLAG_DECRYPTED)) |
| 834 | return RX_DROP_UNUSABLE; |
| 835 | |
| 836 | if (!ieee80211_is_data(hdr->frame_control)) |
| 837 | return RX_CONTINUE; |
| 838 | |
| 839 | cs = rx->sta->cipher_scheme; |
| 840 | |
| 841 | data_len = rx->skb->len - hdrlen - cs->hdr_len; |
| 842 | |
| 843 | if (data_len < 0) |
| 844 | return RX_DROP_UNUSABLE; |
| 845 | |
| 846 | if (ieee80211_is_data_qos(hdr->frame_control)) |
| 847 | qos_tid = *ieee80211_get_qos_ctl(hdr) & |
| 848 | IEEE80211_QOS_CTL_TID_MASK; |
| 849 | else |
| 850 | qos_tid = 0; |
| 851 | |
| 852 | if (skb_linearize(rx->skb)) |
| 853 | return RX_DROP_UNUSABLE; |
| 854 | |
| 855 | hdr = (struct ieee80211_hdr *)rx->skb->data; |
| 856 | |
| 857 | rx_pn = key->u.gen.rx_pn[qos_tid]; |
| 858 | skb_pn = rx->skb->data + hdrlen + cs->pn_off; |
| 859 | |
| 860 | if (ieee80211_crypto_cs_pn_compare(skb_pn, rx_pn, cs->pn_len) <= 0) |
| 861 | return RX_DROP_UNUSABLE; |
| 862 | |
| 863 | memcpy(rx_pn, skb_pn, cs->pn_len); |
| 864 | |
| 865 | /* remove security header and MIC */ |
| 866 | if (pskb_trim(rx->skb, rx->skb->len - cs->mic_len)) |
| 867 | return RX_DROP_UNUSABLE; |
| 868 | |
| 869 | memmove(rx->skb->data + cs->hdr_len, rx->skb->data, hdrlen); |
| 870 | skb_pull(rx->skb, cs->hdr_len); |
| 871 | |
| 872 | return RX_CONTINUE; |
| 873 | } |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 874 | |
| 875 | static void bip_aad(struct sk_buff *skb, u8 *aad) |
| 876 | { |
Jouni Malinen | 33766368 | 2012-09-30 19:47:40 +0300 | [diff] [blame] | 877 | __le16 mask_fc; |
| 878 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; |
| 879 | |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 880 | /* BIP AAD: FC(masked) || A1 || A2 || A3 */ |
| 881 | |
| 882 | /* FC type/subtype */ |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 883 | /* Mask FC Retry, PwrMgt, MoreData flags to zero */ |
Jouni Malinen | 33766368 | 2012-09-30 19:47:40 +0300 | [diff] [blame] | 884 | mask_fc = hdr->frame_control; |
| 885 | mask_fc &= ~cpu_to_le16(IEEE80211_FCTL_RETRY | IEEE80211_FCTL_PM | |
| 886 | IEEE80211_FCTL_MOREDATA); |
| 887 | put_unaligned(mask_fc, (__le16 *) &aad[0]); |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 888 | /* A1 || A2 || A3 */ |
Jouni Malinen | 33766368 | 2012-09-30 19:47:40 +0300 | [diff] [blame] | 889 | memcpy(aad + 2, &hdr->addr1, 3 * ETH_ALEN); |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 890 | } |
| 891 | |
| 892 | |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 893 | static inline void bip_ipn_set64(u8 *d, u64 pn) |
| 894 | { |
| 895 | *d++ = pn; |
| 896 | *d++ = pn >> 8; |
| 897 | *d++ = pn >> 16; |
| 898 | *d++ = pn >> 24; |
| 899 | *d++ = pn >> 32; |
| 900 | *d = pn >> 40; |
| 901 | } |
| 902 | |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 903 | static inline void bip_ipn_swap(u8 *d, const u8 *s) |
| 904 | { |
| 905 | *d++ = s[5]; |
| 906 | *d++ = s[4]; |
| 907 | *d++ = s[3]; |
| 908 | *d++ = s[2]; |
| 909 | *d++ = s[1]; |
| 910 | *d = s[0]; |
| 911 | } |
| 912 | |
| 913 | |
| 914 | ieee80211_tx_result |
| 915 | ieee80211_crypto_aes_cmac_encrypt(struct ieee80211_tx_data *tx) |
| 916 | { |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 917 | struct sk_buff *skb; |
| 918 | struct ieee80211_tx_info *info; |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 919 | struct ieee80211_key *key = tx->key; |
| 920 | struct ieee80211_mmie *mmie; |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 921 | u8 aad[20]; |
| 922 | u64 pn64; |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 923 | |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 924 | if (WARN_ON(skb_queue_len(&tx->skbs) != 1)) |
| 925 | return TX_DROP; |
| 926 | |
| 927 | skb = skb_peek(&tx->skbs); |
| 928 | |
| 929 | info = IEEE80211_SKB_CB(skb); |
| 930 | |
Johannes Berg | 813d766 | 2010-01-17 01:47:58 +0100 | [diff] [blame] | 931 | if (info->control.hw_key) |
Johannes Berg | 252b86c | 2011-11-16 15:28:55 +0100 | [diff] [blame] | 932 | return TX_CONTINUE; |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 933 | |
| 934 | if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie))) |
| 935 | return TX_DROP; |
| 936 | |
| 937 | mmie = (struct ieee80211_mmie *) skb_put(skb, sizeof(*mmie)); |
| 938 | mmie->element_id = WLAN_EID_MMIE; |
| 939 | mmie->length = sizeof(*mmie) - 2; |
| 940 | mmie->key_id = cpu_to_le16(key->conf.keyidx); |
| 941 | |
| 942 | /* PN = PN + 1 */ |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 943 | pn64 = atomic64_inc_return(&key->u.aes_cmac.tx_pn); |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 944 | |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 945 | bip_ipn_set64(mmie->sequence_number, pn64); |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 946 | |
| 947 | bip_aad(skb, aad); |
| 948 | |
| 949 | /* |
| 950 | * MIC = AES-128-CMAC(IGTK, AAD || Management Frame Body || MMIE, 64) |
| 951 | */ |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 952 | ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad, |
| 953 | skb->data + 24, skb->len - 24, mmie->mic); |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 954 | |
| 955 | return TX_CONTINUE; |
| 956 | } |
| 957 | |
Jouni Malinen | 56c52da | 2015-01-24 19:52:08 +0200 | [diff] [blame] | 958 | ieee80211_tx_result |
| 959 | ieee80211_crypto_aes_cmac_256_encrypt(struct ieee80211_tx_data *tx) |
| 960 | { |
| 961 | struct sk_buff *skb; |
| 962 | struct ieee80211_tx_info *info; |
| 963 | struct ieee80211_key *key = tx->key; |
| 964 | struct ieee80211_mmie_16 *mmie; |
| 965 | u8 aad[20]; |
| 966 | u64 pn64; |
| 967 | |
| 968 | if (WARN_ON(skb_queue_len(&tx->skbs) != 1)) |
| 969 | return TX_DROP; |
| 970 | |
| 971 | skb = skb_peek(&tx->skbs); |
| 972 | |
| 973 | info = IEEE80211_SKB_CB(skb); |
| 974 | |
| 975 | if (info->control.hw_key) |
| 976 | return TX_CONTINUE; |
| 977 | |
| 978 | if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie))) |
| 979 | return TX_DROP; |
| 980 | |
| 981 | mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie)); |
| 982 | mmie->element_id = WLAN_EID_MMIE; |
| 983 | mmie->length = sizeof(*mmie) - 2; |
| 984 | mmie->key_id = cpu_to_le16(key->conf.keyidx); |
| 985 | |
| 986 | /* PN = PN + 1 */ |
| 987 | pn64 = atomic64_inc_return(&key->u.aes_cmac.tx_pn); |
| 988 | |
| 989 | bip_ipn_set64(mmie->sequence_number, pn64); |
| 990 | |
| 991 | bip_aad(skb, aad); |
| 992 | |
| 993 | /* MIC = AES-256-CMAC(IGTK, AAD || Management Frame Body || MMIE, 128) |
| 994 | */ |
| 995 | ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad, |
| 996 | skb->data + 24, skb->len - 24, mmie->mic); |
| 997 | |
| 998 | return TX_CONTINUE; |
| 999 | } |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 1000 | |
| 1001 | ieee80211_rx_result |
| 1002 | ieee80211_crypto_aes_cmac_decrypt(struct ieee80211_rx_data *rx) |
| 1003 | { |
| 1004 | struct sk_buff *skb = rx->skb; |
Johannes Berg | eb9fb5b | 2009-11-16 13:58:20 +0100 | [diff] [blame] | 1005 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 1006 | struct ieee80211_key *key = rx->key; |
| 1007 | struct ieee80211_mmie *mmie; |
| 1008 | u8 aad[20], mic[8], ipn[6]; |
| 1009 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data; |
| 1010 | |
| 1011 | if (!ieee80211_is_mgmt(hdr->frame_control)) |
| 1012 | return RX_CONTINUE; |
| 1013 | |
Johannes Berg | a828691 | 2012-03-12 13:49:14 +0100 | [diff] [blame] | 1014 | /* management frames are already linear */ |
| 1015 | |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 1016 | if (skb->len < 24 + sizeof(*mmie)) |
| 1017 | return RX_DROP_UNUSABLE; |
| 1018 | |
| 1019 | mmie = (struct ieee80211_mmie *) |
| 1020 | (skb->data + skb->len - sizeof(*mmie)); |
| 1021 | if (mmie->element_id != WLAN_EID_MMIE || |
| 1022 | mmie->length != sizeof(*mmie) - 2) |
| 1023 | return RX_DROP_UNUSABLE; /* Invalid MMIE */ |
| 1024 | |
| 1025 | bip_ipn_swap(ipn, mmie->sequence_number); |
| 1026 | |
| 1027 | if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) { |
| 1028 | key->u.aes_cmac.replays++; |
| 1029 | return RX_DROP_UNUSABLE; |
| 1030 | } |
| 1031 | |
Johannes Berg | eb9fb5b | 2009-11-16 13:58:20 +0100 | [diff] [blame] | 1032 | if (!(status->flag & RX_FLAG_DECRYPTED)) { |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 1033 | /* hardware didn't decrypt/verify MIC */ |
| 1034 | bip_aad(skb, aad); |
Johannes Berg | 75396ae | 2011-07-06 22:00:35 +0200 | [diff] [blame] | 1035 | ieee80211_aes_cmac(key->u.aes_cmac.tfm, aad, |
Jouni Malinen | 765cb46 | 2009-01-08 13:32:01 +0200 | [diff] [blame] | 1036 | skb->data + 24, skb->len - 24, mic); |
| 1037 | if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) { |
| 1038 | key->u.aes_cmac.icverrors++; |
| 1039 | return RX_DROP_UNUSABLE; |
| 1040 | } |
| 1041 | } |
| 1042 | |
| 1043 | memcpy(key->u.aes_cmac.rx_pn, ipn, 6); |
| 1044 | |
| 1045 | /* Remove MMIE */ |
| 1046 | skb_trim(skb, skb->len - sizeof(*mmie)); |
| 1047 | |
| 1048 | return RX_CONTINUE; |
| 1049 | } |
Yoni Divinsky | d32a102 | 2012-01-16 15:18:59 +0200 | [diff] [blame] | 1050 | |
Jouni Malinen | 56c52da | 2015-01-24 19:52:08 +0200 | [diff] [blame] | 1051 | ieee80211_rx_result |
| 1052 | ieee80211_crypto_aes_cmac_256_decrypt(struct ieee80211_rx_data *rx) |
| 1053 | { |
| 1054 | struct sk_buff *skb = rx->skb; |
| 1055 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
| 1056 | struct ieee80211_key *key = rx->key; |
| 1057 | struct ieee80211_mmie_16 *mmie; |
| 1058 | u8 aad[20], mic[16], ipn[6]; |
| 1059 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 1060 | |
| 1061 | if (!ieee80211_is_mgmt(hdr->frame_control)) |
| 1062 | return RX_CONTINUE; |
| 1063 | |
| 1064 | /* management frames are already linear */ |
| 1065 | |
| 1066 | if (skb->len < 24 + sizeof(*mmie)) |
| 1067 | return RX_DROP_UNUSABLE; |
| 1068 | |
| 1069 | mmie = (struct ieee80211_mmie_16 *) |
| 1070 | (skb->data + skb->len - sizeof(*mmie)); |
| 1071 | if (mmie->element_id != WLAN_EID_MMIE || |
| 1072 | mmie->length != sizeof(*mmie) - 2) |
| 1073 | return RX_DROP_UNUSABLE; /* Invalid MMIE */ |
| 1074 | |
| 1075 | bip_ipn_swap(ipn, mmie->sequence_number); |
| 1076 | |
| 1077 | if (memcmp(ipn, key->u.aes_cmac.rx_pn, 6) <= 0) { |
| 1078 | key->u.aes_cmac.replays++; |
| 1079 | return RX_DROP_UNUSABLE; |
| 1080 | } |
| 1081 | |
| 1082 | if (!(status->flag & RX_FLAG_DECRYPTED)) { |
| 1083 | /* hardware didn't decrypt/verify MIC */ |
| 1084 | bip_aad(skb, aad); |
| 1085 | ieee80211_aes_cmac_256(key->u.aes_cmac.tfm, aad, |
| 1086 | skb->data + 24, skb->len - 24, mic); |
| 1087 | if (memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) { |
| 1088 | key->u.aes_cmac.icverrors++; |
| 1089 | return RX_DROP_UNUSABLE; |
| 1090 | } |
| 1091 | } |
| 1092 | |
| 1093 | memcpy(key->u.aes_cmac.rx_pn, ipn, 6); |
| 1094 | |
| 1095 | /* Remove MMIE */ |
| 1096 | skb_trim(skb, skb->len - sizeof(*mmie)); |
| 1097 | |
| 1098 | return RX_CONTINUE; |
| 1099 | } |
| 1100 | |
Yoni Divinsky | d32a102 | 2012-01-16 15:18:59 +0200 | [diff] [blame] | 1101 | ieee80211_tx_result |
Jouni Malinen | 8ade538 | 2015-01-24 19:52:09 +0200 | [diff] [blame] | 1102 | ieee80211_crypto_aes_gmac_encrypt(struct ieee80211_tx_data *tx) |
| 1103 | { |
| 1104 | struct sk_buff *skb; |
| 1105 | struct ieee80211_tx_info *info; |
| 1106 | struct ieee80211_key *key = tx->key; |
| 1107 | struct ieee80211_mmie_16 *mmie; |
| 1108 | struct ieee80211_hdr *hdr; |
| 1109 | u8 aad[20]; |
| 1110 | u64 pn64; |
| 1111 | u8 nonce[12]; |
| 1112 | |
| 1113 | if (WARN_ON(skb_queue_len(&tx->skbs) != 1)) |
| 1114 | return TX_DROP; |
| 1115 | |
| 1116 | skb = skb_peek(&tx->skbs); |
| 1117 | |
| 1118 | info = IEEE80211_SKB_CB(skb); |
| 1119 | |
| 1120 | if (info->control.hw_key) |
| 1121 | return TX_CONTINUE; |
| 1122 | |
| 1123 | if (WARN_ON(skb_tailroom(skb) < sizeof(*mmie))) |
| 1124 | return TX_DROP; |
| 1125 | |
| 1126 | mmie = (struct ieee80211_mmie_16 *)skb_put(skb, sizeof(*mmie)); |
| 1127 | mmie->element_id = WLAN_EID_MMIE; |
| 1128 | mmie->length = sizeof(*mmie) - 2; |
| 1129 | mmie->key_id = cpu_to_le16(key->conf.keyidx); |
| 1130 | |
| 1131 | /* PN = PN + 1 */ |
| 1132 | pn64 = atomic64_inc_return(&key->u.aes_gmac.tx_pn); |
| 1133 | |
| 1134 | bip_ipn_set64(mmie->sequence_number, pn64); |
| 1135 | |
| 1136 | bip_aad(skb, aad); |
| 1137 | |
| 1138 | hdr = (struct ieee80211_hdr *)skb->data; |
| 1139 | memcpy(nonce, hdr->addr2, ETH_ALEN); |
| 1140 | bip_ipn_swap(nonce + ETH_ALEN, mmie->sequence_number); |
| 1141 | |
| 1142 | /* MIC = AES-GMAC(IGTK, AAD || Management Frame Body || MMIE, 128) */ |
| 1143 | if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce, |
| 1144 | skb->data + 24, skb->len - 24, mmie->mic) < 0) |
| 1145 | return TX_DROP; |
| 1146 | |
| 1147 | return TX_CONTINUE; |
| 1148 | } |
| 1149 | |
| 1150 | ieee80211_rx_result |
| 1151 | ieee80211_crypto_aes_gmac_decrypt(struct ieee80211_rx_data *rx) |
| 1152 | { |
| 1153 | struct sk_buff *skb = rx->skb; |
| 1154 | struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb); |
| 1155 | struct ieee80211_key *key = rx->key; |
| 1156 | struct ieee80211_mmie_16 *mmie; |
| 1157 | u8 aad[20], mic[16], ipn[6], nonce[12]; |
| 1158 | struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; |
| 1159 | |
| 1160 | if (!ieee80211_is_mgmt(hdr->frame_control)) |
| 1161 | return RX_CONTINUE; |
| 1162 | |
| 1163 | /* management frames are already linear */ |
| 1164 | |
| 1165 | if (skb->len < 24 + sizeof(*mmie)) |
| 1166 | return RX_DROP_UNUSABLE; |
| 1167 | |
| 1168 | mmie = (struct ieee80211_mmie_16 *) |
| 1169 | (skb->data + skb->len - sizeof(*mmie)); |
| 1170 | if (mmie->element_id != WLAN_EID_MMIE || |
| 1171 | mmie->length != sizeof(*mmie) - 2) |
| 1172 | return RX_DROP_UNUSABLE; /* Invalid MMIE */ |
| 1173 | |
| 1174 | bip_ipn_swap(ipn, mmie->sequence_number); |
| 1175 | |
| 1176 | if (memcmp(ipn, key->u.aes_gmac.rx_pn, 6) <= 0) { |
| 1177 | key->u.aes_gmac.replays++; |
| 1178 | return RX_DROP_UNUSABLE; |
| 1179 | } |
| 1180 | |
| 1181 | if (!(status->flag & RX_FLAG_DECRYPTED)) { |
| 1182 | /* hardware didn't decrypt/verify MIC */ |
| 1183 | bip_aad(skb, aad); |
| 1184 | |
| 1185 | memcpy(nonce, hdr->addr2, ETH_ALEN); |
| 1186 | memcpy(nonce + ETH_ALEN, ipn, 6); |
| 1187 | |
| 1188 | if (ieee80211_aes_gmac(key->u.aes_gmac.tfm, aad, nonce, |
| 1189 | skb->data + 24, skb->len - 24, |
| 1190 | mic) < 0 || |
| 1191 | memcmp(mic, mmie->mic, sizeof(mmie->mic)) != 0) { |
| 1192 | key->u.aes_gmac.icverrors++; |
| 1193 | return RX_DROP_UNUSABLE; |
| 1194 | } |
| 1195 | } |
| 1196 | |
| 1197 | memcpy(key->u.aes_gmac.rx_pn, ipn, 6); |
| 1198 | |
| 1199 | /* Remove MMIE */ |
| 1200 | skb_trim(skb, skb->len - sizeof(*mmie)); |
| 1201 | |
| 1202 | return RX_CONTINUE; |
| 1203 | } |
| 1204 | |
| 1205 | ieee80211_tx_result |
Yoni Divinsky | d32a102 | 2012-01-16 15:18:59 +0200 | [diff] [blame] | 1206 | ieee80211_crypto_hw_encrypt(struct ieee80211_tx_data *tx) |
| 1207 | { |
| 1208 | struct sk_buff *skb; |
| 1209 | struct ieee80211_tx_info *info = NULL; |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 1210 | ieee80211_tx_result res; |
Yoni Divinsky | d32a102 | 2012-01-16 15:18:59 +0200 | [diff] [blame] | 1211 | |
| 1212 | skb_queue_walk(&tx->skbs, skb) { |
| 1213 | info = IEEE80211_SKB_CB(skb); |
| 1214 | |
| 1215 | /* handle hw-only algorithm */ |
| 1216 | if (!info->control.hw_key) |
| 1217 | return TX_DROP; |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 1218 | |
Cedric Izoard | c7ef38e | 2015-03-17 10:47:33 +0000 | [diff] [blame] | 1219 | if (tx->key->flags & KEY_FLAG_CIPHER_SCHEME) { |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 1220 | res = ieee80211_crypto_cs_encrypt(tx, skb); |
| 1221 | if (res != TX_CONTINUE) |
| 1222 | return res; |
| 1223 | } |
Yoni Divinsky | d32a102 | 2012-01-16 15:18:59 +0200 | [diff] [blame] | 1224 | } |
| 1225 | |
| 1226 | ieee80211_tx_set_protected(tx); |
| 1227 | |
| 1228 | return TX_CONTINUE; |
| 1229 | } |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 1230 | |
| 1231 | ieee80211_rx_result |
| 1232 | ieee80211_crypto_hw_decrypt(struct ieee80211_rx_data *rx) |
| 1233 | { |
Max Stepanov | aeb136c | 2014-07-09 16:55:32 +0300 | [diff] [blame] | 1234 | if (rx->sta && rx->sta->cipher_scheme) |
Max Stepanov | 2475b1cc | 2013-03-24 14:23:27 +0200 | [diff] [blame] | 1235 | return ieee80211_crypto_cs_decrypt(rx); |
| 1236 | |
| 1237 | return RX_DROP_UNUSABLE; |
| 1238 | } |