llsec.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2014 Fraunhofer ITWM
  4. *
  5. * Written by:
  6. * Phoebe Buckheister <phoebe.buckheister@itwm.fraunhofer.de>
  7. */
  8. #include <linux/err.h>
  9. #include <linux/bug.h>
  10. #include <linux/completion.h>
  11. #include <linux/ieee802154.h>
  12. #include <linux/rculist.h>
  13. #include <crypto/aead.h>
  14. #include <crypto/skcipher.h>
  15. #include "ieee802154_i.h"
  16. #include "llsec.h"
  17. static void llsec_key_put(struct mac802154_llsec_key *key);
  18. static bool llsec_key_id_equal(const struct ieee802154_llsec_key_id *a,
  19. const struct ieee802154_llsec_key_id *b);
  20. static void llsec_dev_free(struct mac802154_llsec_device *dev);
  21. void mac802154_llsec_init(struct mac802154_llsec *sec)
  22. {
  23. memset(sec, 0, sizeof(*sec));
  24. memset(&sec->params.default_key_source, 0xFF, IEEE802154_ADDR_LEN);
  25. INIT_LIST_HEAD(&sec->table.security_levels);
  26. INIT_LIST_HEAD(&sec->table.devices);
  27. INIT_LIST_HEAD(&sec->table.keys);
  28. hash_init(sec->devices_short);
  29. hash_init(sec->devices_hw);
  30. rwlock_init(&sec->lock);
  31. }
  32. void mac802154_llsec_destroy(struct mac802154_llsec *sec)
  33. {
  34. struct ieee802154_llsec_seclevel *sl, *sn;
  35. struct ieee802154_llsec_device *dev, *dn;
  36. struct ieee802154_llsec_key_entry *key, *kn;
  37. list_for_each_entry_safe(sl, sn, &sec->table.security_levels, list) {
  38. struct mac802154_llsec_seclevel *msl;
  39. msl = container_of(sl, struct mac802154_llsec_seclevel, level);
  40. list_del(&sl->list);
  41. kfree_sensitive(msl);
  42. }
  43. list_for_each_entry_safe(dev, dn, &sec->table.devices, list) {
  44. struct mac802154_llsec_device *mdev;
  45. mdev = container_of(dev, struct mac802154_llsec_device, dev);
  46. list_del(&dev->list);
  47. llsec_dev_free(mdev);
  48. }
  49. list_for_each_entry_safe(key, kn, &sec->table.keys, list) {
  50. struct mac802154_llsec_key *mkey;
  51. mkey = container_of(key->key, struct mac802154_llsec_key, key);
  52. list_del(&key->list);
  53. llsec_key_put(mkey);
  54. kfree_sensitive(key);
  55. }
  56. }
  57. int mac802154_llsec_get_params(struct mac802154_llsec *sec,
  58. struct ieee802154_llsec_params *params)
  59. {
  60. read_lock_bh(&sec->lock);
  61. *params = sec->params;
  62. read_unlock_bh(&sec->lock);
  63. return 0;
  64. }
  65. int mac802154_llsec_set_params(struct mac802154_llsec *sec,
  66. const struct ieee802154_llsec_params *params,
  67. int changed)
  68. {
  69. write_lock_bh(&sec->lock);
  70. if (changed & IEEE802154_LLSEC_PARAM_ENABLED)
  71. sec->params.enabled = params->enabled;
  72. if (changed & IEEE802154_LLSEC_PARAM_FRAME_COUNTER)
  73. sec->params.frame_counter = params->frame_counter;
  74. if (changed & IEEE802154_LLSEC_PARAM_OUT_LEVEL)
  75. sec->params.out_level = params->out_level;
  76. if (changed & IEEE802154_LLSEC_PARAM_OUT_KEY)
  77. sec->params.out_key = params->out_key;
  78. if (changed & IEEE802154_LLSEC_PARAM_KEY_SOURCE)
  79. sec->params.default_key_source = params->default_key_source;
  80. if (changed & IEEE802154_LLSEC_PARAM_PAN_ID)
  81. sec->params.pan_id = params->pan_id;
  82. if (changed & IEEE802154_LLSEC_PARAM_HWADDR)
  83. sec->params.hwaddr = params->hwaddr;
  84. if (changed & IEEE802154_LLSEC_PARAM_COORD_HWADDR)
  85. sec->params.coord_hwaddr = params->coord_hwaddr;
  86. if (changed & IEEE802154_LLSEC_PARAM_COORD_SHORTADDR)
  87. sec->params.coord_shortaddr = params->coord_shortaddr;
  88. write_unlock_bh(&sec->lock);
  89. return 0;
  90. }
  91. static struct mac802154_llsec_key*
  92. llsec_key_alloc(const struct ieee802154_llsec_key *template)
  93. {
  94. const int authsizes[3] = { 4, 8, 16 };
  95. struct mac802154_llsec_key *key;
  96. int i;
  97. key = kzalloc(sizeof(*key), GFP_KERNEL);
  98. if (!key)
  99. return NULL;
  100. kref_init(&key->ref);
  101. key->key = *template;
  102. BUILD_BUG_ON(ARRAY_SIZE(authsizes) != ARRAY_SIZE(key->tfm));
  103. for (i = 0; i < ARRAY_SIZE(key->tfm); i++) {
  104. key->tfm[i] = crypto_alloc_aead("ccm(aes)", 0,
  105. CRYPTO_ALG_ASYNC);
  106. if (IS_ERR(key->tfm[i]))
  107. goto err_tfm;
  108. if (crypto_aead_setkey(key->tfm[i], template->key,
  109. IEEE802154_LLSEC_KEY_SIZE))
  110. goto err_tfm;
  111. if (crypto_aead_setauthsize(key->tfm[i], authsizes[i]))
  112. goto err_tfm;
  113. }
  114. key->tfm0 = crypto_alloc_sync_skcipher("ctr(aes)", 0, 0);
  115. if (IS_ERR(key->tfm0))
  116. goto err_tfm;
  117. if (crypto_sync_skcipher_setkey(key->tfm0, template->key,
  118. IEEE802154_LLSEC_KEY_SIZE))
  119. goto err_tfm0;
  120. return key;
  121. err_tfm0:
  122. crypto_free_sync_skcipher(key->tfm0);
  123. err_tfm:
  124. for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
  125. if (!IS_ERR_OR_NULL(key->tfm[i]))
  126. crypto_free_aead(key->tfm[i]);
  127. kfree_sensitive(key);
  128. return NULL;
  129. }
  130. static void llsec_key_release(struct kref *ref)
  131. {
  132. struct mac802154_llsec_key *key;
  133. int i;
  134. key = container_of(ref, struct mac802154_llsec_key, ref);
  135. for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
  136. crypto_free_aead(key->tfm[i]);
  137. crypto_free_sync_skcipher(key->tfm0);
  138. kfree_sensitive(key);
  139. }
  140. static struct mac802154_llsec_key*
  141. llsec_key_get(struct mac802154_llsec_key *key)
  142. {
  143. kref_get(&key->ref);
  144. return key;
  145. }
  146. static void llsec_key_put(struct mac802154_llsec_key *key)
  147. {
  148. kref_put(&key->ref, llsec_key_release);
  149. }
  150. static bool llsec_key_id_equal(const struct ieee802154_llsec_key_id *a,
  151. const struct ieee802154_llsec_key_id *b)
  152. {
  153. if (a->mode != b->mode)
  154. return false;
  155. if (a->mode == IEEE802154_SCF_KEY_IMPLICIT)
  156. return ieee802154_addr_equal(&a->device_addr, &b->device_addr);
  157. if (a->id != b->id)
  158. return false;
  159. switch (a->mode) {
  160. case IEEE802154_SCF_KEY_INDEX:
  161. return true;
  162. case IEEE802154_SCF_KEY_SHORT_INDEX:
  163. return a->short_source == b->short_source;
  164. case IEEE802154_SCF_KEY_HW_INDEX:
  165. return a->extended_source == b->extended_source;
  166. }
  167. return false;
  168. }
  169. int mac802154_llsec_key_add(struct mac802154_llsec *sec,
  170. const struct ieee802154_llsec_key_id *id,
  171. const struct ieee802154_llsec_key *key)
  172. {
  173. struct mac802154_llsec_key *mkey = NULL;
  174. struct ieee802154_llsec_key_entry *pos, *new;
  175. if (!(key->frame_types & (1 << IEEE802154_FC_TYPE_MAC_CMD)) &&
  176. key->cmd_frame_ids)
  177. return -EINVAL;
  178. list_for_each_entry(pos, &sec->table.keys, list) {
  179. if (llsec_key_id_equal(&pos->id, id))
  180. return -EEXIST;
  181. if (memcmp(pos->key->key, key->key,
  182. IEEE802154_LLSEC_KEY_SIZE))
  183. continue;
  184. mkey = container_of(pos->key, struct mac802154_llsec_key, key);
  185. /* Don't allow multiple instances of the same AES key to have
  186. * different allowed frame types/command frame ids, as this is
  187. * not possible in the 802.15.4 PIB.
  188. */
  189. if (pos->key->frame_types != key->frame_types ||
  190. pos->key->cmd_frame_ids != key->cmd_frame_ids)
  191. return -EEXIST;
  192. break;
  193. }
  194. new = kzalloc(sizeof(*new), GFP_KERNEL);
  195. if (!new)
  196. return -ENOMEM;
  197. if (!mkey)
  198. mkey = llsec_key_alloc(key);
  199. else
  200. mkey = llsec_key_get(mkey);
  201. if (!mkey)
  202. goto fail;
  203. new->id = *id;
  204. new->key = &mkey->key;
  205. list_add_rcu(&new->list, &sec->table.keys);
  206. return 0;
  207. fail:
  208. kfree_sensitive(new);
  209. return -ENOMEM;
  210. }
  211. int mac802154_llsec_key_del(struct mac802154_llsec *sec,
  212. const struct ieee802154_llsec_key_id *key)
  213. {
  214. struct ieee802154_llsec_key_entry *pos;
  215. list_for_each_entry(pos, &sec->table.keys, list) {
  216. struct mac802154_llsec_key *mkey;
  217. mkey = container_of(pos->key, struct mac802154_llsec_key, key);
  218. if (llsec_key_id_equal(&pos->id, key)) {
  219. list_del_rcu(&pos->list);
  220. llsec_key_put(mkey);
  221. return 0;
  222. }
  223. }
  224. return -ENOENT;
  225. }
  226. static bool llsec_dev_use_shortaddr(__le16 short_addr)
  227. {
  228. return short_addr != cpu_to_le16(IEEE802154_ADDR_UNDEF) &&
  229. short_addr != cpu_to_le16(0xffff);
  230. }
  231. static u32 llsec_dev_hash_short(__le16 short_addr, __le16 pan_id)
  232. {
  233. return ((__force u16)short_addr) << 16 | (__force u16)pan_id;
  234. }
  235. static u64 llsec_dev_hash_long(__le64 hwaddr)
  236. {
  237. return (__force u64)hwaddr;
  238. }
  239. static struct mac802154_llsec_device*
  240. llsec_dev_find_short(struct mac802154_llsec *sec, __le16 short_addr,
  241. __le16 pan_id)
  242. {
  243. struct mac802154_llsec_device *dev;
  244. u32 key = llsec_dev_hash_short(short_addr, pan_id);
  245. hash_for_each_possible_rcu(sec->devices_short, dev, bucket_s, key) {
  246. if (dev->dev.short_addr == short_addr &&
  247. dev->dev.pan_id == pan_id)
  248. return dev;
  249. }
  250. return NULL;
  251. }
  252. static struct mac802154_llsec_device*
  253. llsec_dev_find_long(struct mac802154_llsec *sec, __le64 hwaddr)
  254. {
  255. struct mac802154_llsec_device *dev;
  256. u64 key = llsec_dev_hash_long(hwaddr);
  257. hash_for_each_possible_rcu(sec->devices_hw, dev, bucket_hw, key) {
  258. if (dev->dev.hwaddr == hwaddr)
  259. return dev;
  260. }
  261. return NULL;
  262. }
  263. static void llsec_dev_free(struct mac802154_llsec_device *dev)
  264. {
  265. struct ieee802154_llsec_device_key *pos, *pn;
  266. struct mac802154_llsec_device_key *devkey;
  267. list_for_each_entry_safe(pos, pn, &dev->dev.keys, list) {
  268. devkey = container_of(pos, struct mac802154_llsec_device_key,
  269. devkey);
  270. list_del(&pos->list);
  271. kfree_sensitive(devkey);
  272. }
  273. kfree_sensitive(dev);
  274. }
  275. int mac802154_llsec_dev_add(struct mac802154_llsec *sec,
  276. const struct ieee802154_llsec_device *dev)
  277. {
  278. struct mac802154_llsec_device *entry;
  279. u32 skey = llsec_dev_hash_short(dev->short_addr, dev->pan_id);
  280. u64 hwkey = llsec_dev_hash_long(dev->hwaddr);
  281. BUILD_BUG_ON(sizeof(hwkey) != IEEE802154_ADDR_LEN);
  282. if ((llsec_dev_use_shortaddr(dev->short_addr) &&
  283. llsec_dev_find_short(sec, dev->short_addr, dev->pan_id)) ||
  284. llsec_dev_find_long(sec, dev->hwaddr))
  285. return -EEXIST;
  286. entry = kmalloc(sizeof(*entry), GFP_KERNEL);
  287. if (!entry)
  288. return -ENOMEM;
  289. entry->dev = *dev;
  290. spin_lock_init(&entry->lock);
  291. INIT_LIST_HEAD(&entry->dev.keys);
  292. if (llsec_dev_use_shortaddr(dev->short_addr))
  293. hash_add_rcu(sec->devices_short, &entry->bucket_s, skey);
  294. else
  295. INIT_HLIST_NODE(&entry->bucket_s);
  296. hash_add_rcu(sec->devices_hw, &entry->bucket_hw, hwkey);
  297. list_add_tail_rcu(&entry->dev.list, &sec->table.devices);
  298. return 0;
  299. }
  300. static void llsec_dev_free_rcu(struct rcu_head *rcu)
  301. {
  302. llsec_dev_free(container_of(rcu, struct mac802154_llsec_device, rcu));
  303. }
  304. int mac802154_llsec_dev_del(struct mac802154_llsec *sec, __le64 device_addr)
  305. {
  306. struct mac802154_llsec_device *pos;
  307. pos = llsec_dev_find_long(sec, device_addr);
  308. if (!pos)
  309. return -ENOENT;
  310. hash_del_rcu(&pos->bucket_s);
  311. hash_del_rcu(&pos->bucket_hw);
  312. list_del_rcu(&pos->dev.list);
  313. call_rcu(&pos->rcu, llsec_dev_free_rcu);
  314. return 0;
  315. }
  316. static struct mac802154_llsec_device_key*
  317. llsec_devkey_find(struct mac802154_llsec_device *dev,
  318. const struct ieee802154_llsec_key_id *key)
  319. {
  320. struct ieee802154_llsec_device_key *devkey;
  321. list_for_each_entry_rcu(devkey, &dev->dev.keys, list) {
  322. if (!llsec_key_id_equal(key, &devkey->key_id))
  323. continue;
  324. return container_of(devkey, struct mac802154_llsec_device_key,
  325. devkey);
  326. }
  327. return NULL;
  328. }
  329. int mac802154_llsec_devkey_add(struct mac802154_llsec *sec,
  330. __le64 dev_addr,
  331. const struct ieee802154_llsec_device_key *key)
  332. {
  333. struct mac802154_llsec_device *dev;
  334. struct mac802154_llsec_device_key *devkey;
  335. dev = llsec_dev_find_long(sec, dev_addr);
  336. if (!dev)
  337. return -ENOENT;
  338. if (llsec_devkey_find(dev, &key->key_id))
  339. return -EEXIST;
  340. devkey = kmalloc(sizeof(*devkey), GFP_KERNEL);
  341. if (!devkey)
  342. return -ENOMEM;
  343. devkey->devkey = *key;
  344. list_add_tail_rcu(&devkey->devkey.list, &dev->dev.keys);
  345. return 0;
  346. }
  347. int mac802154_llsec_devkey_del(struct mac802154_llsec *sec,
  348. __le64 dev_addr,
  349. const struct ieee802154_llsec_device_key *key)
  350. {
  351. struct mac802154_llsec_device *dev;
  352. struct mac802154_llsec_device_key *devkey;
  353. dev = llsec_dev_find_long(sec, dev_addr);
  354. if (!dev)
  355. return -ENOENT;
  356. devkey = llsec_devkey_find(dev, &key->key_id);
  357. if (!devkey)
  358. return -ENOENT;
  359. list_del_rcu(&devkey->devkey.list);
  360. kfree_rcu(devkey, rcu);
  361. return 0;
  362. }
  363. static struct mac802154_llsec_seclevel*
  364. llsec_find_seclevel(const struct mac802154_llsec *sec,
  365. const struct ieee802154_llsec_seclevel *sl)
  366. {
  367. struct ieee802154_llsec_seclevel *pos;
  368. list_for_each_entry(pos, &sec->table.security_levels, list) {
  369. if (pos->frame_type != sl->frame_type ||
  370. (pos->frame_type == IEEE802154_FC_TYPE_MAC_CMD &&
  371. pos->cmd_frame_id != sl->cmd_frame_id) ||
  372. pos->device_override != sl->device_override ||
  373. pos->sec_levels != sl->sec_levels)
  374. continue;
  375. return container_of(pos, struct mac802154_llsec_seclevel,
  376. level);
  377. }
  378. return NULL;
  379. }
  380. int mac802154_llsec_seclevel_add(struct mac802154_llsec *sec,
  381. const struct ieee802154_llsec_seclevel *sl)
  382. {
  383. struct mac802154_llsec_seclevel *entry;
  384. if (llsec_find_seclevel(sec, sl))
  385. return -EEXIST;
  386. entry = kmalloc(sizeof(*entry), GFP_KERNEL);
  387. if (!entry)
  388. return -ENOMEM;
  389. entry->level = *sl;
  390. list_add_tail_rcu(&entry->level.list, &sec->table.security_levels);
  391. return 0;
  392. }
  393. int mac802154_llsec_seclevel_del(struct mac802154_llsec *sec,
  394. const struct ieee802154_llsec_seclevel *sl)
  395. {
  396. struct mac802154_llsec_seclevel *pos;
  397. pos = llsec_find_seclevel(sec, sl);
  398. if (!pos)
  399. return -ENOENT;
  400. list_del_rcu(&pos->level.list);
  401. kfree_rcu(pos, rcu);
  402. return 0;
  403. }
  404. static int llsec_recover_addr(struct mac802154_llsec *sec,
  405. struct ieee802154_addr *addr)
  406. {
  407. __le16 caddr = sec->params.coord_shortaddr;
  408. addr->pan_id = sec->params.pan_id;
  409. if (caddr == cpu_to_le16(IEEE802154_ADDR_BROADCAST)) {
  410. return -EINVAL;
  411. } else if (caddr == cpu_to_le16(IEEE802154_ADDR_UNDEF)) {
  412. addr->extended_addr = sec->params.coord_hwaddr;
  413. addr->mode = IEEE802154_ADDR_LONG;
  414. } else {
  415. addr->short_addr = sec->params.coord_shortaddr;
  416. addr->mode = IEEE802154_ADDR_SHORT;
  417. }
  418. return 0;
  419. }
  420. static struct mac802154_llsec_key*
  421. llsec_lookup_key(struct mac802154_llsec *sec,
  422. const struct ieee802154_hdr *hdr,
  423. const struct ieee802154_addr *addr,
  424. struct ieee802154_llsec_key_id *key_id)
  425. {
  426. struct ieee802154_addr devaddr = *addr;
  427. u8 key_id_mode = hdr->sec.key_id_mode;
  428. struct ieee802154_llsec_key_entry *key_entry;
  429. struct mac802154_llsec_key *key;
  430. if (key_id_mode == IEEE802154_SCF_KEY_IMPLICIT &&
  431. devaddr.mode == IEEE802154_ADDR_NONE) {
  432. if (hdr->fc.type == IEEE802154_FC_TYPE_BEACON) {
  433. devaddr.extended_addr = sec->params.coord_hwaddr;
  434. devaddr.mode = IEEE802154_ADDR_LONG;
  435. } else if (llsec_recover_addr(sec, &devaddr) < 0) {
  436. return NULL;
  437. }
  438. }
  439. list_for_each_entry_rcu(key_entry, &sec->table.keys, list) {
  440. const struct ieee802154_llsec_key_id *id = &key_entry->id;
  441. if (!(key_entry->key->frame_types & BIT(hdr->fc.type)))
  442. continue;
  443. if (id->mode != key_id_mode)
  444. continue;
  445. if (key_id_mode == IEEE802154_SCF_KEY_IMPLICIT) {
  446. if (ieee802154_addr_equal(&devaddr, &id->device_addr))
  447. goto found;
  448. } else {
  449. if (id->id != hdr->sec.key_id)
  450. continue;
  451. if ((key_id_mode == IEEE802154_SCF_KEY_INDEX) ||
  452. (key_id_mode == IEEE802154_SCF_KEY_SHORT_INDEX &&
  453. id->short_source == hdr->sec.short_src) ||
  454. (key_id_mode == IEEE802154_SCF_KEY_HW_INDEX &&
  455. id->extended_source == hdr->sec.extended_src))
  456. goto found;
  457. }
  458. }
  459. return NULL;
  460. found:
  461. key = container_of(key_entry->key, struct mac802154_llsec_key, key);
  462. if (key_id)
  463. *key_id = key_entry->id;
  464. return llsec_key_get(key);
  465. }
  466. static void llsec_geniv(u8 iv[16], __le64 addr,
  467. const struct ieee802154_sechdr *sec)
  468. {
  469. __be64 addr_bytes = (__force __be64) swab64((__force u64) addr);
  470. __be32 frame_counter = (__force __be32) swab32((__force u32) sec->frame_counter);
  471. iv[0] = 1; /* L' = L - 1 = 1 */
  472. memcpy(iv + 1, &addr_bytes, sizeof(addr_bytes));
  473. memcpy(iv + 9, &frame_counter, sizeof(frame_counter));
  474. iv[13] = sec->level;
  475. iv[14] = 0;
  476. iv[15] = 1;
  477. }
  478. static int
  479. llsec_do_encrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
  480. const struct ieee802154_hdr *hdr,
  481. struct mac802154_llsec_key *key)
  482. {
  483. u8 iv[16];
  484. struct scatterlist src;
  485. SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
  486. int err, datalen;
  487. unsigned char *data;
  488. llsec_geniv(iv, sec->params.hwaddr, &hdr->sec);
  489. /* Compute data payload offset and data length */
  490. data = skb_mac_header(skb) + skb->mac_len;
  491. datalen = skb_tail_pointer(skb) - data;
  492. sg_init_one(&src, data, datalen);
  493. skcipher_request_set_sync_tfm(req, key->tfm0);
  494. skcipher_request_set_callback(req, 0, NULL, NULL);
  495. skcipher_request_set_crypt(req, &src, &src, datalen, iv);
  496. err = crypto_skcipher_encrypt(req);
  497. skcipher_request_zero(req);
  498. return err;
  499. }
  500. static struct crypto_aead*
  501. llsec_tfm_by_len(struct mac802154_llsec_key *key, int authlen)
  502. {
  503. int i;
  504. for (i = 0; i < ARRAY_SIZE(key->tfm); i++)
  505. if (crypto_aead_authsize(key->tfm[i]) == authlen)
  506. return key->tfm[i];
  507. BUG();
  508. }
  509. static int
  510. llsec_do_encrypt_auth(struct sk_buff *skb, const struct mac802154_llsec *sec,
  511. const struct ieee802154_hdr *hdr,
  512. struct mac802154_llsec_key *key)
  513. {
  514. u8 iv[16];
  515. unsigned char *data;
  516. int authlen, assoclen, datalen, rc;
  517. struct scatterlist sg;
  518. struct aead_request *req;
  519. authlen = ieee802154_sechdr_authtag_len(&hdr->sec);
  520. llsec_geniv(iv, sec->params.hwaddr, &hdr->sec);
  521. req = aead_request_alloc(llsec_tfm_by_len(key, authlen), GFP_ATOMIC);
  522. if (!req)
  523. return -ENOMEM;
  524. assoclen = skb->mac_len;
  525. data = skb_mac_header(skb) + skb->mac_len;
  526. datalen = skb_tail_pointer(skb) - data;
  527. skb_put(skb, authlen);
  528. sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen + authlen);
  529. if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
  530. assoclen += datalen;
  531. datalen = 0;
  532. }
  533. aead_request_set_callback(req, 0, NULL, NULL);
  534. aead_request_set_crypt(req, &sg, &sg, datalen, iv);
  535. aead_request_set_ad(req, assoclen);
  536. rc = crypto_aead_encrypt(req);
  537. kfree_sensitive(req);
  538. return rc;
  539. }
  540. static int llsec_do_encrypt(struct sk_buff *skb,
  541. const struct mac802154_llsec *sec,
  542. const struct ieee802154_hdr *hdr,
  543. struct mac802154_llsec_key *key)
  544. {
  545. if (hdr->sec.level == IEEE802154_SCF_SECLEVEL_ENC)
  546. return llsec_do_encrypt_unauth(skb, sec, hdr, key);
  547. else
  548. return llsec_do_encrypt_auth(skb, sec, hdr, key);
  549. }
  550. int mac802154_llsec_encrypt(struct mac802154_llsec *sec, struct sk_buff *skb)
  551. {
  552. struct ieee802154_hdr hdr;
  553. int rc, authlen, hlen;
  554. struct mac802154_llsec_key *key;
  555. u32 frame_ctr;
  556. hlen = ieee802154_hdr_pull(skb, &hdr);
  557. if (hlen < 0 || hdr.fc.type != IEEE802154_FC_TYPE_DATA)
  558. return -EINVAL;
  559. if (!hdr.fc.security_enabled ||
  560. (hdr.sec.level == IEEE802154_SCF_SECLEVEL_NONE)) {
  561. skb_push(skb, hlen);
  562. return 0;
  563. }
  564. authlen = ieee802154_sechdr_authtag_len(&hdr.sec);
  565. if (skb->len + hlen + authlen + IEEE802154_MFR_SIZE > IEEE802154_MTU)
  566. return -EMSGSIZE;
  567. rcu_read_lock();
  568. read_lock_bh(&sec->lock);
  569. if (!sec->params.enabled) {
  570. rc = -EINVAL;
  571. goto fail_read;
  572. }
  573. key = llsec_lookup_key(sec, &hdr, &hdr.dest, NULL);
  574. if (!key) {
  575. rc = -ENOKEY;
  576. goto fail_read;
  577. }
  578. read_unlock_bh(&sec->lock);
  579. write_lock_bh(&sec->lock);
  580. frame_ctr = be32_to_cpu(sec->params.frame_counter);
  581. hdr.sec.frame_counter = cpu_to_le32(frame_ctr);
  582. if (frame_ctr == 0xFFFFFFFF) {
  583. write_unlock_bh(&sec->lock);
  584. llsec_key_put(key);
  585. rc = -EOVERFLOW;
  586. goto fail;
  587. }
  588. sec->params.frame_counter = cpu_to_be32(frame_ctr + 1);
  589. write_unlock_bh(&sec->lock);
  590. rcu_read_unlock();
  591. skb->mac_len = ieee802154_hdr_push(skb, &hdr);
  592. skb_reset_mac_header(skb);
  593. rc = llsec_do_encrypt(skb, sec, &hdr, key);
  594. llsec_key_put(key);
  595. return rc;
  596. fail_read:
  597. read_unlock_bh(&sec->lock);
  598. fail:
  599. rcu_read_unlock();
  600. return rc;
  601. }
  602. static struct mac802154_llsec_device*
  603. llsec_lookup_dev(struct mac802154_llsec *sec,
  604. const struct ieee802154_addr *addr)
  605. {
  606. struct ieee802154_addr devaddr = *addr;
  607. struct mac802154_llsec_device *dev = NULL;
  608. if (devaddr.mode == IEEE802154_ADDR_NONE &&
  609. llsec_recover_addr(sec, &devaddr) < 0)
  610. return NULL;
  611. if (devaddr.mode == IEEE802154_ADDR_SHORT) {
  612. u32 key = llsec_dev_hash_short(devaddr.short_addr,
  613. devaddr.pan_id);
  614. hash_for_each_possible_rcu(sec->devices_short, dev,
  615. bucket_s, key) {
  616. if (dev->dev.pan_id == devaddr.pan_id &&
  617. dev->dev.short_addr == devaddr.short_addr)
  618. return dev;
  619. }
  620. } else {
  621. u64 key = llsec_dev_hash_long(devaddr.extended_addr);
  622. hash_for_each_possible_rcu(sec->devices_hw, dev,
  623. bucket_hw, key) {
  624. if (dev->dev.hwaddr == devaddr.extended_addr)
  625. return dev;
  626. }
  627. }
  628. return NULL;
  629. }
  630. static int
  631. llsec_lookup_seclevel(const struct mac802154_llsec *sec,
  632. u8 frame_type, u8 cmd_frame_id,
  633. struct ieee802154_llsec_seclevel *rlevel)
  634. {
  635. struct ieee802154_llsec_seclevel *level;
  636. list_for_each_entry_rcu(level, &sec->table.security_levels, list) {
  637. if (level->frame_type == frame_type &&
  638. (frame_type != IEEE802154_FC_TYPE_MAC_CMD ||
  639. level->cmd_frame_id == cmd_frame_id)) {
  640. *rlevel = *level;
  641. return 0;
  642. }
  643. }
  644. return -EINVAL;
  645. }
  646. static int
  647. llsec_do_decrypt_unauth(struct sk_buff *skb, const struct mac802154_llsec *sec,
  648. const struct ieee802154_hdr *hdr,
  649. struct mac802154_llsec_key *key, __le64 dev_addr)
  650. {
  651. u8 iv[16];
  652. unsigned char *data;
  653. int datalen;
  654. struct scatterlist src;
  655. SYNC_SKCIPHER_REQUEST_ON_STACK(req, key->tfm0);
  656. int err;
  657. llsec_geniv(iv, dev_addr, &hdr->sec);
  658. data = skb_mac_header(skb) + skb->mac_len;
  659. datalen = skb_tail_pointer(skb) - data;
  660. sg_init_one(&src, data, datalen);
  661. skcipher_request_set_sync_tfm(req, key->tfm0);
  662. skcipher_request_set_callback(req, 0, NULL, NULL);
  663. skcipher_request_set_crypt(req, &src, &src, datalen, iv);
  664. err = crypto_skcipher_decrypt(req);
  665. skcipher_request_zero(req);
  666. return err;
  667. }
  668. static int
  669. llsec_do_decrypt_auth(struct sk_buff *skb, const struct mac802154_llsec *sec,
  670. const struct ieee802154_hdr *hdr,
  671. struct mac802154_llsec_key *key, __le64 dev_addr)
  672. {
  673. u8 iv[16];
  674. unsigned char *data;
  675. int authlen, datalen, assoclen, rc;
  676. struct scatterlist sg;
  677. struct aead_request *req;
  678. authlen = ieee802154_sechdr_authtag_len(&hdr->sec);
  679. llsec_geniv(iv, dev_addr, &hdr->sec);
  680. req = aead_request_alloc(llsec_tfm_by_len(key, authlen), GFP_ATOMIC);
  681. if (!req)
  682. return -ENOMEM;
  683. assoclen = skb->mac_len;
  684. data = skb_mac_header(skb) + skb->mac_len;
  685. datalen = skb_tail_pointer(skb) - data;
  686. sg_init_one(&sg, skb_mac_header(skb), assoclen + datalen);
  687. if (!(hdr->sec.level & IEEE802154_SCF_SECLEVEL_ENC)) {
  688. assoclen += datalen - authlen;
  689. datalen = authlen;
  690. }
  691. aead_request_set_callback(req, 0, NULL, NULL);
  692. aead_request_set_crypt(req, &sg, &sg, datalen, iv);
  693. aead_request_set_ad(req, assoclen);
  694. rc = crypto_aead_decrypt(req);
  695. kfree_sensitive(req);
  696. skb_trim(skb, skb->len - authlen);
  697. return rc;
  698. }
  699. static int
  700. llsec_do_decrypt(struct sk_buff *skb, const struct mac802154_llsec *sec,
  701. const struct ieee802154_hdr *hdr,
  702. struct mac802154_llsec_key *key, __le64 dev_addr)
  703. {
  704. if (hdr->sec.level == IEEE802154_SCF_SECLEVEL_ENC)
  705. return llsec_do_decrypt_unauth(skb, sec, hdr, key, dev_addr);
  706. else
  707. return llsec_do_decrypt_auth(skb, sec, hdr, key, dev_addr);
  708. }
  709. static int
  710. llsec_update_devkey_record(struct mac802154_llsec_device *dev,
  711. const struct ieee802154_llsec_key_id *in_key)
  712. {
  713. struct mac802154_llsec_device_key *devkey;
  714. devkey = llsec_devkey_find(dev, in_key);
  715. if (!devkey) {
  716. struct mac802154_llsec_device_key *next;
  717. next = kzalloc(sizeof(*devkey), GFP_ATOMIC);
  718. if (!next)
  719. return -ENOMEM;
  720. next->devkey.key_id = *in_key;
  721. spin_lock_bh(&dev->lock);
  722. devkey = llsec_devkey_find(dev, in_key);
  723. if (!devkey)
  724. list_add_rcu(&next->devkey.list, &dev->dev.keys);
  725. else
  726. kfree_sensitive(next);
  727. spin_unlock_bh(&dev->lock);
  728. }
  729. return 0;
  730. }
  731. static int
  732. llsec_update_devkey_info(struct mac802154_llsec_device *dev,
  733. const struct ieee802154_llsec_key_id *in_key,
  734. u32 frame_counter)
  735. {
  736. struct mac802154_llsec_device_key *devkey = NULL;
  737. if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RESTRICT) {
  738. devkey = llsec_devkey_find(dev, in_key);
  739. if (!devkey)
  740. return -ENOENT;
  741. }
  742. if (dev->dev.key_mode == IEEE802154_LLSEC_DEVKEY_RECORD) {
  743. int rc = llsec_update_devkey_record(dev, in_key);
  744. if (rc < 0)
  745. return rc;
  746. }
  747. spin_lock_bh(&dev->lock);
  748. if ((!devkey && frame_counter < dev->dev.frame_counter) ||
  749. (devkey && frame_counter < devkey->devkey.frame_counter)) {
  750. spin_unlock_bh(&dev->lock);
  751. return -EINVAL;
  752. }
  753. if (devkey)
  754. devkey->devkey.frame_counter = frame_counter + 1;
  755. else
  756. dev->dev.frame_counter = frame_counter + 1;
  757. spin_unlock_bh(&dev->lock);
  758. return 0;
  759. }
  760. int mac802154_llsec_decrypt(struct mac802154_llsec *sec, struct sk_buff *skb)
  761. {
  762. struct ieee802154_hdr hdr;
  763. struct mac802154_llsec_key *key;
  764. struct ieee802154_llsec_key_id key_id;
  765. struct mac802154_llsec_device *dev;
  766. struct ieee802154_llsec_seclevel seclevel;
  767. int err;
  768. __le64 dev_addr;
  769. u32 frame_ctr;
  770. if (ieee802154_hdr_peek(skb, &hdr) < 0)
  771. return -EINVAL;
  772. if (!hdr.fc.security_enabled)
  773. return 0;
  774. if (hdr.fc.version == 0)
  775. return -EINVAL;
  776. read_lock_bh(&sec->lock);
  777. if (!sec->params.enabled) {
  778. read_unlock_bh(&sec->lock);
  779. return -EINVAL;
  780. }
  781. read_unlock_bh(&sec->lock);
  782. rcu_read_lock();
  783. key = llsec_lookup_key(sec, &hdr, &hdr.source, &key_id);
  784. if (!key) {
  785. err = -ENOKEY;
  786. goto fail;
  787. }
  788. dev = llsec_lookup_dev(sec, &hdr.source);
  789. if (!dev) {
  790. err = -EINVAL;
  791. goto fail_dev;
  792. }
  793. if (llsec_lookup_seclevel(sec, hdr.fc.type, 0, &seclevel) < 0) {
  794. err = -EINVAL;
  795. goto fail_dev;
  796. }
  797. if (!(seclevel.sec_levels & BIT(hdr.sec.level)) &&
  798. (hdr.sec.level == 0 && seclevel.device_override &&
  799. !dev->dev.seclevel_exempt)) {
  800. err = -EINVAL;
  801. goto fail_dev;
  802. }
  803. frame_ctr = le32_to_cpu(hdr.sec.frame_counter);
  804. if (frame_ctr == 0xffffffff) {
  805. err = -EOVERFLOW;
  806. goto fail_dev;
  807. }
  808. err = llsec_update_devkey_info(dev, &key_id, frame_ctr);
  809. if (err)
  810. goto fail_dev;
  811. dev_addr = dev->dev.hwaddr;
  812. rcu_read_unlock();
  813. err = llsec_do_decrypt(skb, sec, &hdr, key, dev_addr);
  814. llsec_key_put(key);
  815. return err;
  816. fail_dev:
  817. llsec_key_put(key);
  818. fail:
  819. rcu_read_unlock();
  820. return err;
  821. }