key.c 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* RxRPC key management
  3. *
  4. * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
  5. * Written by David Howells (dhowells@redhat.com)
  6. *
  7. * RxRPC keys should have a description of describing their purpose:
  8. * "afs@CAMBRIDGE.REDHAT.COM>
  9. */
  10. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  11. #include <crypto/skcipher.h>
  12. #include <linux/module.h>
  13. #include <linux/net.h>
  14. #include <linux/skbuff.h>
  15. #include <linux/key-type.h>
  16. #include <linux/ctype.h>
  17. #include <linux/slab.h>
  18. #include <net/sock.h>
  19. #include <net/af_rxrpc.h>
  20. #include <keys/rxrpc-type.h>
  21. #include <keys/user-type.h>
  22. #include "ar-internal.h"
  23. static int rxrpc_vet_description_s(const char *);
  24. static int rxrpc_preparse(struct key_preparsed_payload *);
  25. static int rxrpc_preparse_s(struct key_preparsed_payload *);
  26. static void rxrpc_free_preparse(struct key_preparsed_payload *);
  27. static void rxrpc_free_preparse_s(struct key_preparsed_payload *);
  28. static void rxrpc_destroy(struct key *);
  29. static void rxrpc_destroy_s(struct key *);
  30. static void rxrpc_describe(const struct key *, struct seq_file *);
  31. static long rxrpc_read(const struct key *, char *, size_t);
  32. /*
  33. * rxrpc defined keys take an arbitrary string as the description and an
  34. * arbitrary blob of data as the payload
  35. */
  36. struct key_type key_type_rxrpc = {
  37. .name = "rxrpc",
  38. .flags = KEY_TYPE_NET_DOMAIN,
  39. .preparse = rxrpc_preparse,
  40. .free_preparse = rxrpc_free_preparse,
  41. .instantiate = generic_key_instantiate,
  42. .destroy = rxrpc_destroy,
  43. .describe = rxrpc_describe,
  44. .read = rxrpc_read,
  45. };
  46. EXPORT_SYMBOL(key_type_rxrpc);
  47. /*
  48. * rxrpc server defined keys take "<serviceId>:<securityIndex>" as the
  49. * description and an 8-byte decryption key as the payload
  50. */
  51. struct key_type key_type_rxrpc_s = {
  52. .name = "rxrpc_s",
  53. .flags = KEY_TYPE_NET_DOMAIN,
  54. .vet_description = rxrpc_vet_description_s,
  55. .preparse = rxrpc_preparse_s,
  56. .free_preparse = rxrpc_free_preparse_s,
  57. .instantiate = generic_key_instantiate,
  58. .destroy = rxrpc_destroy_s,
  59. .describe = rxrpc_describe,
  60. };
  61. /*
  62. * Vet the description for an RxRPC server key
  63. */
  64. static int rxrpc_vet_description_s(const char *desc)
  65. {
  66. unsigned long num;
  67. char *p;
  68. num = simple_strtoul(desc, &p, 10);
  69. if (*p != ':' || num > 65535)
  70. return -EINVAL;
  71. num = simple_strtoul(p + 1, &p, 10);
  72. if (*p || num < 1 || num > 255)
  73. return -EINVAL;
  74. return 0;
  75. }
  76. /*
  77. * parse an RxKAD type XDR format token
  78. * - the caller guarantees we have at least 4 words
  79. */
  80. static int rxrpc_preparse_xdr_rxkad(struct key_preparsed_payload *prep,
  81. size_t datalen,
  82. const __be32 *xdr, unsigned int toklen)
  83. {
  84. struct rxrpc_key_token *token, **pptoken;
  85. time64_t expiry;
  86. size_t plen;
  87. u32 tktlen;
  88. _enter(",{%x,%x,%x,%x},%u",
  89. ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
  90. toklen);
  91. if (toklen <= 8 * 4)
  92. return -EKEYREJECTED;
  93. tktlen = ntohl(xdr[7]);
  94. _debug("tktlen: %x", tktlen);
  95. if (tktlen > AFSTOKEN_RK_TIX_MAX)
  96. return -EKEYREJECTED;
  97. if (toklen < 8 * 4 + tktlen)
  98. return -EKEYREJECTED;
  99. plen = sizeof(*token) + sizeof(*token->kad) + tktlen;
  100. prep->quotalen = datalen + plen;
  101. plen -= sizeof(*token);
  102. token = kzalloc(sizeof(*token), GFP_KERNEL);
  103. if (!token)
  104. return -ENOMEM;
  105. token->kad = kzalloc(plen, GFP_KERNEL);
  106. if (!token->kad) {
  107. kfree(token);
  108. return -ENOMEM;
  109. }
  110. token->security_index = RXRPC_SECURITY_RXKAD;
  111. token->kad->ticket_len = tktlen;
  112. token->kad->vice_id = ntohl(xdr[0]);
  113. token->kad->kvno = ntohl(xdr[1]);
  114. token->kad->start = ntohl(xdr[4]);
  115. token->kad->expiry = ntohl(xdr[5]);
  116. token->kad->primary_flag = ntohl(xdr[6]);
  117. memcpy(&token->kad->session_key, &xdr[2], 8);
  118. memcpy(&token->kad->ticket, &xdr[8], tktlen);
  119. _debug("SCIX: %u", token->security_index);
  120. _debug("TLEN: %u", token->kad->ticket_len);
  121. _debug("EXPY: %x", token->kad->expiry);
  122. _debug("KVNO: %u", token->kad->kvno);
  123. _debug("PRIM: %u", token->kad->primary_flag);
  124. _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
  125. token->kad->session_key[0], token->kad->session_key[1],
  126. token->kad->session_key[2], token->kad->session_key[3],
  127. token->kad->session_key[4], token->kad->session_key[5],
  128. token->kad->session_key[6], token->kad->session_key[7]);
  129. if (token->kad->ticket_len >= 8)
  130. _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
  131. token->kad->ticket[0], token->kad->ticket[1],
  132. token->kad->ticket[2], token->kad->ticket[3],
  133. token->kad->ticket[4], token->kad->ticket[5],
  134. token->kad->ticket[6], token->kad->ticket[7]);
  135. /* count the number of tokens attached */
  136. prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
  137. /* attach the data */
  138. for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
  139. *pptoken;
  140. pptoken = &(*pptoken)->next)
  141. continue;
  142. *pptoken = token;
  143. expiry = rxrpc_u32_to_time64(token->kad->expiry);
  144. if (expiry < prep->expiry)
  145. prep->expiry = expiry;
  146. _leave(" = 0");
  147. return 0;
  148. }
  149. static void rxrpc_free_krb5_principal(struct krb5_principal *princ)
  150. {
  151. int loop;
  152. if (princ->name_parts) {
  153. for (loop = princ->n_name_parts - 1; loop >= 0; loop--)
  154. kfree(princ->name_parts[loop]);
  155. kfree(princ->name_parts);
  156. }
  157. kfree(princ->realm);
  158. }
  159. static void rxrpc_free_krb5_tagged(struct krb5_tagged_data *td)
  160. {
  161. kfree(td->data);
  162. }
  163. /*
  164. * free up an RxK5 token
  165. */
  166. static void rxrpc_rxk5_free(struct rxk5_key *rxk5)
  167. {
  168. int loop;
  169. rxrpc_free_krb5_principal(&rxk5->client);
  170. rxrpc_free_krb5_principal(&rxk5->server);
  171. rxrpc_free_krb5_tagged(&rxk5->session);
  172. if (rxk5->addresses) {
  173. for (loop = rxk5->n_addresses - 1; loop >= 0; loop--)
  174. rxrpc_free_krb5_tagged(&rxk5->addresses[loop]);
  175. kfree(rxk5->addresses);
  176. }
  177. if (rxk5->authdata) {
  178. for (loop = rxk5->n_authdata - 1; loop >= 0; loop--)
  179. rxrpc_free_krb5_tagged(&rxk5->authdata[loop]);
  180. kfree(rxk5->authdata);
  181. }
  182. kfree(rxk5->ticket);
  183. kfree(rxk5->ticket2);
  184. kfree(rxk5);
  185. }
  186. /*
  187. * extract a krb5 principal
  188. */
  189. static int rxrpc_krb5_decode_principal(struct krb5_principal *princ,
  190. const __be32 **_xdr,
  191. unsigned int *_toklen)
  192. {
  193. const __be32 *xdr = *_xdr;
  194. unsigned int toklen = *_toklen, n_parts, loop, tmp, paddedlen;
  195. /* there must be at least one name, and at least #names+1 length
  196. * words */
  197. if (toklen <= 12)
  198. return -EINVAL;
  199. _enter(",{%x,%x,%x},%u",
  200. ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), toklen);
  201. n_parts = ntohl(*xdr++);
  202. toklen -= 4;
  203. if (n_parts <= 0 || n_parts > AFSTOKEN_K5_COMPONENTS_MAX)
  204. return -EINVAL;
  205. princ->n_name_parts = n_parts;
  206. if (toklen <= (n_parts + 1) * 4)
  207. return -EINVAL;
  208. princ->name_parts = kcalloc(n_parts, sizeof(char *), GFP_KERNEL);
  209. if (!princ->name_parts)
  210. return -ENOMEM;
  211. for (loop = 0; loop < n_parts; loop++) {
  212. if (toklen < 4)
  213. return -EINVAL;
  214. tmp = ntohl(*xdr++);
  215. toklen -= 4;
  216. if (tmp <= 0 || tmp > AFSTOKEN_STRING_MAX)
  217. return -EINVAL;
  218. paddedlen = (tmp + 3) & ~3;
  219. if (paddedlen > toklen)
  220. return -EINVAL;
  221. princ->name_parts[loop] = kmalloc(tmp + 1, GFP_KERNEL);
  222. if (!princ->name_parts[loop])
  223. return -ENOMEM;
  224. memcpy(princ->name_parts[loop], xdr, tmp);
  225. princ->name_parts[loop][tmp] = 0;
  226. toklen -= paddedlen;
  227. xdr += paddedlen >> 2;
  228. }
  229. if (toklen < 4)
  230. return -EINVAL;
  231. tmp = ntohl(*xdr++);
  232. toklen -= 4;
  233. if (tmp <= 0 || tmp > AFSTOKEN_K5_REALM_MAX)
  234. return -EINVAL;
  235. paddedlen = (tmp + 3) & ~3;
  236. if (paddedlen > toklen)
  237. return -EINVAL;
  238. princ->realm = kmalloc(tmp + 1, GFP_KERNEL);
  239. if (!princ->realm)
  240. return -ENOMEM;
  241. memcpy(princ->realm, xdr, tmp);
  242. princ->realm[tmp] = 0;
  243. toklen -= paddedlen;
  244. xdr += paddedlen >> 2;
  245. _debug("%s/...@%s", princ->name_parts[0], princ->realm);
  246. *_xdr = xdr;
  247. *_toklen = toklen;
  248. _leave(" = 0 [toklen=%u]", toklen);
  249. return 0;
  250. }
  251. /*
  252. * extract a piece of krb5 tagged data
  253. */
  254. static int rxrpc_krb5_decode_tagged_data(struct krb5_tagged_data *td,
  255. size_t max_data_size,
  256. const __be32 **_xdr,
  257. unsigned int *_toklen)
  258. {
  259. const __be32 *xdr = *_xdr;
  260. unsigned int toklen = *_toklen, len, paddedlen;
  261. /* there must be at least one tag and one length word */
  262. if (toklen <= 8)
  263. return -EINVAL;
  264. _enter(",%zu,{%x,%x},%u",
  265. max_data_size, ntohl(xdr[0]), ntohl(xdr[1]), toklen);
  266. td->tag = ntohl(*xdr++);
  267. len = ntohl(*xdr++);
  268. toklen -= 8;
  269. if (len > max_data_size)
  270. return -EINVAL;
  271. paddedlen = (len + 3) & ~3;
  272. if (paddedlen > toklen)
  273. return -EINVAL;
  274. td->data_len = len;
  275. if (len > 0) {
  276. td->data = kmemdup(xdr, len, GFP_KERNEL);
  277. if (!td->data)
  278. return -ENOMEM;
  279. toklen -= paddedlen;
  280. xdr += paddedlen >> 2;
  281. }
  282. _debug("tag %x len %x", td->tag, td->data_len);
  283. *_xdr = xdr;
  284. *_toklen = toklen;
  285. _leave(" = 0 [toklen=%u]", toklen);
  286. return 0;
  287. }
  288. /*
  289. * extract an array of tagged data
  290. */
  291. static int rxrpc_krb5_decode_tagged_array(struct krb5_tagged_data **_td,
  292. u8 *_n_elem,
  293. u8 max_n_elem,
  294. size_t max_elem_size,
  295. const __be32 **_xdr,
  296. unsigned int *_toklen)
  297. {
  298. struct krb5_tagged_data *td;
  299. const __be32 *xdr = *_xdr;
  300. unsigned int toklen = *_toklen, n_elem, loop;
  301. int ret;
  302. /* there must be at least one count */
  303. if (toklen < 4)
  304. return -EINVAL;
  305. _enter(",,%u,%zu,{%x},%u",
  306. max_n_elem, max_elem_size, ntohl(xdr[0]), toklen);
  307. n_elem = ntohl(*xdr++);
  308. toklen -= 4;
  309. if (n_elem > max_n_elem)
  310. return -EINVAL;
  311. *_n_elem = n_elem;
  312. if (n_elem > 0) {
  313. if (toklen <= (n_elem + 1) * 4)
  314. return -EINVAL;
  315. _debug("n_elem %d", n_elem);
  316. td = kcalloc(n_elem, sizeof(struct krb5_tagged_data),
  317. GFP_KERNEL);
  318. if (!td)
  319. return -ENOMEM;
  320. *_td = td;
  321. for (loop = 0; loop < n_elem; loop++) {
  322. ret = rxrpc_krb5_decode_tagged_data(&td[loop],
  323. max_elem_size,
  324. &xdr, &toklen);
  325. if (ret < 0)
  326. return ret;
  327. }
  328. }
  329. *_xdr = xdr;
  330. *_toklen = toklen;
  331. _leave(" = 0 [toklen=%u]", toklen);
  332. return 0;
  333. }
  334. /*
  335. * extract a krb5 ticket
  336. */
  337. static int rxrpc_krb5_decode_ticket(u8 **_ticket, u16 *_tktlen,
  338. const __be32 **_xdr, unsigned int *_toklen)
  339. {
  340. const __be32 *xdr = *_xdr;
  341. unsigned int toklen = *_toklen, len, paddedlen;
  342. /* there must be at least one length word */
  343. if (toklen <= 4)
  344. return -EINVAL;
  345. _enter(",{%x},%u", ntohl(xdr[0]), toklen);
  346. len = ntohl(*xdr++);
  347. toklen -= 4;
  348. if (len > AFSTOKEN_K5_TIX_MAX)
  349. return -EINVAL;
  350. paddedlen = (len + 3) & ~3;
  351. if (paddedlen > toklen)
  352. return -EINVAL;
  353. *_tktlen = len;
  354. _debug("ticket len %u", len);
  355. if (len > 0) {
  356. *_ticket = kmemdup(xdr, len, GFP_KERNEL);
  357. if (!*_ticket)
  358. return -ENOMEM;
  359. toklen -= paddedlen;
  360. xdr += paddedlen >> 2;
  361. }
  362. *_xdr = xdr;
  363. *_toklen = toklen;
  364. _leave(" = 0 [toklen=%u]", toklen);
  365. return 0;
  366. }
  367. /*
  368. * parse an RxK5 type XDR format token
  369. * - the caller guarantees we have at least 4 words
  370. */
  371. static int rxrpc_preparse_xdr_rxk5(struct key_preparsed_payload *prep,
  372. size_t datalen,
  373. const __be32 *xdr, unsigned int toklen)
  374. {
  375. struct rxrpc_key_token *token, **pptoken;
  376. struct rxk5_key *rxk5;
  377. const __be32 *end_xdr = xdr + (toklen >> 2);
  378. time64_t expiry;
  379. int ret;
  380. _enter(",{%x,%x,%x,%x},%u",
  381. ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
  382. toklen);
  383. /* reserve some payload space for this subkey - the length of the token
  384. * is a reasonable approximation */
  385. prep->quotalen = datalen + toklen;
  386. token = kzalloc(sizeof(*token), GFP_KERNEL);
  387. if (!token)
  388. return -ENOMEM;
  389. rxk5 = kzalloc(sizeof(*rxk5), GFP_KERNEL);
  390. if (!rxk5) {
  391. kfree(token);
  392. return -ENOMEM;
  393. }
  394. token->security_index = RXRPC_SECURITY_RXK5;
  395. token->k5 = rxk5;
  396. /* extract the principals */
  397. ret = rxrpc_krb5_decode_principal(&rxk5->client, &xdr, &toklen);
  398. if (ret < 0)
  399. goto error;
  400. ret = rxrpc_krb5_decode_principal(&rxk5->server, &xdr, &toklen);
  401. if (ret < 0)
  402. goto error;
  403. /* extract the session key and the encoding type (the tag field ->
  404. * ENCTYPE_xxx) */
  405. ret = rxrpc_krb5_decode_tagged_data(&rxk5->session, AFSTOKEN_DATA_MAX,
  406. &xdr, &toklen);
  407. if (ret < 0)
  408. goto error;
  409. if (toklen < 4 * 8 + 2 * 4)
  410. goto inval;
  411. rxk5->authtime = be64_to_cpup((const __be64 *) xdr);
  412. xdr += 2;
  413. rxk5->starttime = be64_to_cpup((const __be64 *) xdr);
  414. xdr += 2;
  415. rxk5->endtime = be64_to_cpup((const __be64 *) xdr);
  416. xdr += 2;
  417. rxk5->renew_till = be64_to_cpup((const __be64 *) xdr);
  418. xdr += 2;
  419. rxk5->is_skey = ntohl(*xdr++);
  420. rxk5->flags = ntohl(*xdr++);
  421. toklen -= 4 * 8 + 2 * 4;
  422. _debug("times: a=%llx s=%llx e=%llx rt=%llx",
  423. rxk5->authtime, rxk5->starttime, rxk5->endtime,
  424. rxk5->renew_till);
  425. _debug("is_skey=%x flags=%x", rxk5->is_skey, rxk5->flags);
  426. /* extract the permitted client addresses */
  427. ret = rxrpc_krb5_decode_tagged_array(&rxk5->addresses,
  428. &rxk5->n_addresses,
  429. AFSTOKEN_K5_ADDRESSES_MAX,
  430. AFSTOKEN_DATA_MAX,
  431. &xdr, &toklen);
  432. if (ret < 0)
  433. goto error;
  434. ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
  435. /* extract the tickets */
  436. ret = rxrpc_krb5_decode_ticket(&rxk5->ticket, &rxk5->ticket_len,
  437. &xdr, &toklen);
  438. if (ret < 0)
  439. goto error;
  440. ret = rxrpc_krb5_decode_ticket(&rxk5->ticket2, &rxk5->ticket2_len,
  441. &xdr, &toklen);
  442. if (ret < 0)
  443. goto error;
  444. ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
  445. /* extract the typed auth data */
  446. ret = rxrpc_krb5_decode_tagged_array(&rxk5->authdata,
  447. &rxk5->n_authdata,
  448. AFSTOKEN_K5_AUTHDATA_MAX,
  449. AFSTOKEN_BDATALN_MAX,
  450. &xdr, &toklen);
  451. if (ret < 0)
  452. goto error;
  453. ASSERTCMP((end_xdr - xdr) << 2, ==, toklen);
  454. if (toklen != 0)
  455. goto inval;
  456. /* attach the payload */
  457. for (pptoken = (struct rxrpc_key_token **)&prep->payload.data[0];
  458. *pptoken;
  459. pptoken = &(*pptoken)->next)
  460. continue;
  461. *pptoken = token;
  462. expiry = rxrpc_u32_to_time64(token->k5->endtime);
  463. if (expiry < prep->expiry)
  464. prep->expiry = expiry;
  465. _leave(" = 0");
  466. return 0;
  467. inval:
  468. ret = -EINVAL;
  469. error:
  470. rxrpc_rxk5_free(rxk5);
  471. kfree(token);
  472. _leave(" = %d", ret);
  473. return ret;
  474. }
  475. /*
  476. * attempt to parse the data as the XDR format
  477. * - the caller guarantees we have more than 7 words
  478. */
  479. static int rxrpc_preparse_xdr(struct key_preparsed_payload *prep)
  480. {
  481. const __be32 *xdr = prep->data, *token;
  482. const char *cp;
  483. unsigned int len, paddedlen, loop, ntoken, toklen, sec_ix;
  484. size_t datalen = prep->datalen;
  485. int ret;
  486. _enter(",{%x,%x,%x,%x},%zu",
  487. ntohl(xdr[0]), ntohl(xdr[1]), ntohl(xdr[2]), ntohl(xdr[3]),
  488. prep->datalen);
  489. if (datalen > AFSTOKEN_LENGTH_MAX)
  490. goto not_xdr;
  491. /* XDR is an array of __be32's */
  492. if (datalen & 3)
  493. goto not_xdr;
  494. /* the flags should be 0 (the setpag bit must be handled by
  495. * userspace) */
  496. if (ntohl(*xdr++) != 0)
  497. goto not_xdr;
  498. datalen -= 4;
  499. /* check the cell name */
  500. len = ntohl(*xdr++);
  501. if (len < 1 || len > AFSTOKEN_CELL_MAX)
  502. goto not_xdr;
  503. datalen -= 4;
  504. paddedlen = (len + 3) & ~3;
  505. if (paddedlen > datalen)
  506. goto not_xdr;
  507. cp = (const char *) xdr;
  508. for (loop = 0; loop < len; loop++)
  509. if (!isprint(cp[loop]))
  510. goto not_xdr;
  511. for (; loop < paddedlen; loop++)
  512. if (cp[loop])
  513. goto not_xdr;
  514. _debug("cellname: [%u/%u] '%*.*s'",
  515. len, paddedlen, len, len, (const char *) xdr);
  516. datalen -= paddedlen;
  517. xdr += paddedlen >> 2;
  518. /* get the token count */
  519. if (datalen < 12)
  520. goto not_xdr;
  521. ntoken = ntohl(*xdr++);
  522. datalen -= 4;
  523. _debug("ntoken: %x", ntoken);
  524. if (ntoken < 1 || ntoken > AFSTOKEN_MAX)
  525. goto not_xdr;
  526. /* check each token wrapper */
  527. token = xdr;
  528. loop = ntoken;
  529. do {
  530. if (datalen < 8)
  531. goto not_xdr;
  532. toklen = ntohl(*xdr++);
  533. sec_ix = ntohl(*xdr);
  534. datalen -= 4;
  535. _debug("token: [%x/%zx] %x", toklen, datalen, sec_ix);
  536. paddedlen = (toklen + 3) & ~3;
  537. if (toklen < 20 || toklen > datalen || paddedlen > datalen)
  538. goto not_xdr;
  539. datalen -= paddedlen;
  540. xdr += paddedlen >> 2;
  541. } while (--loop > 0);
  542. _debug("remainder: %zu", datalen);
  543. if (datalen != 0)
  544. goto not_xdr;
  545. /* okay: we're going to assume it's valid XDR format
  546. * - we ignore the cellname, relying on the key to be correctly named
  547. */
  548. do {
  549. xdr = token;
  550. toklen = ntohl(*xdr++);
  551. token = xdr + ((toklen + 3) >> 2);
  552. sec_ix = ntohl(*xdr++);
  553. toklen -= 4;
  554. _debug("TOKEN type=%u [%p-%p]", sec_ix, xdr, token);
  555. switch (sec_ix) {
  556. case RXRPC_SECURITY_RXKAD:
  557. ret = rxrpc_preparse_xdr_rxkad(prep, datalen, xdr, toklen);
  558. if (ret != 0)
  559. goto error;
  560. break;
  561. case RXRPC_SECURITY_RXK5:
  562. ret = rxrpc_preparse_xdr_rxk5(prep, datalen, xdr, toklen);
  563. if (ret != 0)
  564. goto error;
  565. break;
  566. default:
  567. ret = -EPROTONOSUPPORT;
  568. goto error;
  569. }
  570. } while (--ntoken > 0);
  571. _leave(" = 0");
  572. return 0;
  573. not_xdr:
  574. _leave(" = -EPROTO");
  575. return -EPROTO;
  576. error:
  577. _leave(" = %d", ret);
  578. return ret;
  579. }
  580. /*
  581. * Preparse an rxrpc defined key.
  582. *
  583. * Data should be of the form:
  584. * OFFSET LEN CONTENT
  585. * 0 4 key interface version number
  586. * 4 2 security index (type)
  587. * 6 2 ticket length
  588. * 8 4 key expiry time (time_t)
  589. * 12 4 kvno
  590. * 16 8 session key
  591. * 24 [len] ticket
  592. *
  593. * if no data is provided, then a no-security key is made
  594. */
  595. static int rxrpc_preparse(struct key_preparsed_payload *prep)
  596. {
  597. const struct rxrpc_key_data_v1 *v1;
  598. struct rxrpc_key_token *token, **pp;
  599. time64_t expiry;
  600. size_t plen;
  601. u32 kver;
  602. int ret;
  603. _enter("%zu", prep->datalen);
  604. /* handle a no-security key */
  605. if (!prep->data && prep->datalen == 0)
  606. return 0;
  607. /* determine if the XDR payload format is being used */
  608. if (prep->datalen > 7 * 4) {
  609. ret = rxrpc_preparse_xdr(prep);
  610. if (ret != -EPROTO)
  611. return ret;
  612. }
  613. /* get the key interface version number */
  614. ret = -EINVAL;
  615. if (prep->datalen <= 4 || !prep->data)
  616. goto error;
  617. memcpy(&kver, prep->data, sizeof(kver));
  618. prep->data += sizeof(kver);
  619. prep->datalen -= sizeof(kver);
  620. _debug("KEY I/F VERSION: %u", kver);
  621. ret = -EKEYREJECTED;
  622. if (kver != 1)
  623. goto error;
  624. /* deal with a version 1 key */
  625. ret = -EINVAL;
  626. if (prep->datalen < sizeof(*v1))
  627. goto error;
  628. v1 = prep->data;
  629. if (prep->datalen != sizeof(*v1) + v1->ticket_length)
  630. goto error;
  631. _debug("SCIX: %u", v1->security_index);
  632. _debug("TLEN: %u", v1->ticket_length);
  633. _debug("EXPY: %x", v1->expiry);
  634. _debug("KVNO: %u", v1->kvno);
  635. _debug("SKEY: %02x%02x%02x%02x%02x%02x%02x%02x",
  636. v1->session_key[0], v1->session_key[1],
  637. v1->session_key[2], v1->session_key[3],
  638. v1->session_key[4], v1->session_key[5],
  639. v1->session_key[6], v1->session_key[7]);
  640. if (v1->ticket_length >= 8)
  641. _debug("TCKT: %02x%02x%02x%02x%02x%02x%02x%02x",
  642. v1->ticket[0], v1->ticket[1],
  643. v1->ticket[2], v1->ticket[3],
  644. v1->ticket[4], v1->ticket[5],
  645. v1->ticket[6], v1->ticket[7]);
  646. ret = -EPROTONOSUPPORT;
  647. if (v1->security_index != RXRPC_SECURITY_RXKAD)
  648. goto error;
  649. plen = sizeof(*token->kad) + v1->ticket_length;
  650. prep->quotalen = plen + sizeof(*token);
  651. ret = -ENOMEM;
  652. token = kzalloc(sizeof(*token), GFP_KERNEL);
  653. if (!token)
  654. goto error;
  655. token->kad = kzalloc(plen, GFP_KERNEL);
  656. if (!token->kad)
  657. goto error_free;
  658. token->security_index = RXRPC_SECURITY_RXKAD;
  659. token->kad->ticket_len = v1->ticket_length;
  660. token->kad->expiry = v1->expiry;
  661. token->kad->kvno = v1->kvno;
  662. memcpy(&token->kad->session_key, &v1->session_key, 8);
  663. memcpy(&token->kad->ticket, v1->ticket, v1->ticket_length);
  664. /* count the number of tokens attached */
  665. prep->payload.data[1] = (void *)((unsigned long)prep->payload.data[1] + 1);
  666. /* attach the data */
  667. pp = (struct rxrpc_key_token **)&prep->payload.data[0];
  668. while (*pp)
  669. pp = &(*pp)->next;
  670. *pp = token;
  671. expiry = rxrpc_u32_to_time64(token->kad->expiry);
  672. if (expiry < prep->expiry)
  673. prep->expiry = expiry;
  674. token = NULL;
  675. ret = 0;
  676. error_free:
  677. kfree(token);
  678. error:
  679. return ret;
  680. }
  681. /*
  682. * Free token list.
  683. */
  684. static void rxrpc_free_token_list(struct rxrpc_key_token *token)
  685. {
  686. struct rxrpc_key_token *next;
  687. for (; token; token = next) {
  688. next = token->next;
  689. switch (token->security_index) {
  690. case RXRPC_SECURITY_RXKAD:
  691. kfree(token->kad);
  692. break;
  693. case RXRPC_SECURITY_RXK5:
  694. if (token->k5)
  695. rxrpc_rxk5_free(token->k5);
  696. break;
  697. default:
  698. pr_err("Unknown token type %x on rxrpc key\n",
  699. token->security_index);
  700. BUG();
  701. }
  702. kfree(token);
  703. }
  704. }
  705. /*
  706. * Clean up preparse data.
  707. */
  708. static void rxrpc_free_preparse(struct key_preparsed_payload *prep)
  709. {
  710. rxrpc_free_token_list(prep->payload.data[0]);
  711. }
  712. /*
  713. * Preparse a server secret key.
  714. *
  715. * The data should be the 8-byte secret key.
  716. */
  717. static int rxrpc_preparse_s(struct key_preparsed_payload *prep)
  718. {
  719. struct crypto_skcipher *ci;
  720. _enter("%zu", prep->datalen);
  721. if (prep->datalen != 8)
  722. return -EINVAL;
  723. memcpy(&prep->payload.data[2], prep->data, 8);
  724. ci = crypto_alloc_skcipher("pcbc(des)", 0, CRYPTO_ALG_ASYNC);
  725. if (IS_ERR(ci)) {
  726. _leave(" = %ld", PTR_ERR(ci));
  727. return PTR_ERR(ci);
  728. }
  729. if (crypto_skcipher_setkey(ci, prep->data, 8) < 0)
  730. BUG();
  731. prep->payload.data[0] = ci;
  732. _leave(" = 0");
  733. return 0;
  734. }
  735. /*
  736. * Clean up preparse data.
  737. */
  738. static void rxrpc_free_preparse_s(struct key_preparsed_payload *prep)
  739. {
  740. if (prep->payload.data[0])
  741. crypto_free_skcipher(prep->payload.data[0]);
  742. }
  743. /*
  744. * dispose of the data dangling from the corpse of a rxrpc key
  745. */
  746. static void rxrpc_destroy(struct key *key)
  747. {
  748. rxrpc_free_token_list(key->payload.data[0]);
  749. }
  750. /*
  751. * dispose of the data dangling from the corpse of a rxrpc key
  752. */
  753. static void rxrpc_destroy_s(struct key *key)
  754. {
  755. if (key->payload.data[0]) {
  756. crypto_free_skcipher(key->payload.data[0]);
  757. key->payload.data[0] = NULL;
  758. }
  759. }
  760. /*
  761. * describe the rxrpc key
  762. */
  763. static void rxrpc_describe(const struct key *key, struct seq_file *m)
  764. {
  765. seq_puts(m, key->description);
  766. }
  767. /*
  768. * grab the security key for a socket
  769. */
  770. int rxrpc_request_key(struct rxrpc_sock *rx, sockptr_t optval, int optlen)
  771. {
  772. struct key *key;
  773. char *description;
  774. _enter("");
  775. if (optlen <= 0 || optlen > PAGE_SIZE - 1 || rx->securities)
  776. return -EINVAL;
  777. description = memdup_sockptr_nul(optval, optlen);
  778. if (IS_ERR(description))
  779. return PTR_ERR(description);
  780. key = request_key_net(&key_type_rxrpc, description, sock_net(&rx->sk), NULL);
  781. if (IS_ERR(key)) {
  782. kfree(description);
  783. _leave(" = %ld", PTR_ERR(key));
  784. return PTR_ERR(key);
  785. }
  786. rx->key = key;
  787. kfree(description);
  788. _leave(" = 0 [key %x]", key->serial);
  789. return 0;
  790. }
  791. /*
  792. * grab the security keyring for a server socket
  793. */
  794. int rxrpc_server_keyring(struct rxrpc_sock *rx, sockptr_t optval, int optlen)
  795. {
  796. struct key *key;
  797. char *description;
  798. _enter("");
  799. if (optlen <= 0 || optlen > PAGE_SIZE - 1)
  800. return -EINVAL;
  801. description = memdup_sockptr_nul(optval, optlen);
  802. if (IS_ERR(description))
  803. return PTR_ERR(description);
  804. key = request_key(&key_type_keyring, description, NULL);
  805. if (IS_ERR(key)) {
  806. kfree(description);
  807. _leave(" = %ld", PTR_ERR(key));
  808. return PTR_ERR(key);
  809. }
  810. rx->securities = key;
  811. kfree(description);
  812. _leave(" = 0 [key %x]", key->serial);
  813. return 0;
  814. }
  815. /*
  816. * generate a server data key
  817. */
  818. int rxrpc_get_server_data_key(struct rxrpc_connection *conn,
  819. const void *session_key,
  820. time64_t expiry,
  821. u32 kvno)
  822. {
  823. const struct cred *cred = current_cred();
  824. struct key *key;
  825. int ret;
  826. struct {
  827. u32 kver;
  828. struct rxrpc_key_data_v1 v1;
  829. } data;
  830. _enter("");
  831. key = key_alloc(&key_type_rxrpc, "x",
  832. GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred, 0,
  833. KEY_ALLOC_NOT_IN_QUOTA, NULL);
  834. if (IS_ERR(key)) {
  835. _leave(" = -ENOMEM [alloc %ld]", PTR_ERR(key));
  836. return -ENOMEM;
  837. }
  838. _debug("key %d", key_serial(key));
  839. data.kver = 1;
  840. data.v1.security_index = RXRPC_SECURITY_RXKAD;
  841. data.v1.ticket_length = 0;
  842. data.v1.expiry = rxrpc_time64_to_u32(expiry);
  843. data.v1.kvno = 0;
  844. memcpy(&data.v1.session_key, session_key, sizeof(data.v1.session_key));
  845. ret = key_instantiate_and_link(key, &data, sizeof(data), NULL, NULL);
  846. if (ret < 0)
  847. goto error;
  848. conn->params.key = key;
  849. _leave(" = 0 [%d]", key_serial(key));
  850. return 0;
  851. error:
  852. key_revoke(key);
  853. key_put(key);
  854. _leave(" = -ENOMEM [ins %d]", ret);
  855. return -ENOMEM;
  856. }
  857. EXPORT_SYMBOL(rxrpc_get_server_data_key);
  858. /**
  859. * rxrpc_get_null_key - Generate a null RxRPC key
  860. * @keyname: The name to give the key.
  861. *
  862. * Generate a null RxRPC key that can be used to indicate anonymous security is
  863. * required for a particular domain.
  864. */
  865. struct key *rxrpc_get_null_key(const char *keyname)
  866. {
  867. const struct cred *cred = current_cred();
  868. struct key *key;
  869. int ret;
  870. key = key_alloc(&key_type_rxrpc, keyname,
  871. GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
  872. KEY_POS_SEARCH, KEY_ALLOC_NOT_IN_QUOTA, NULL);
  873. if (IS_ERR(key))
  874. return key;
  875. ret = key_instantiate_and_link(key, NULL, 0, NULL, NULL);
  876. if (ret < 0) {
  877. key_revoke(key);
  878. key_put(key);
  879. return ERR_PTR(ret);
  880. }
  881. return key;
  882. }
  883. EXPORT_SYMBOL(rxrpc_get_null_key);
  884. /*
  885. * read the contents of an rxrpc key
  886. * - this returns the result in XDR form
  887. */
  888. static long rxrpc_read(const struct key *key,
  889. char *buffer, size_t buflen)
  890. {
  891. const struct rxrpc_key_token *token;
  892. const struct krb5_principal *princ;
  893. size_t size;
  894. __be32 *xdr, *oldxdr;
  895. u32 cnlen, toksize, ntoks, tok, zero;
  896. u16 toksizes[AFSTOKEN_MAX];
  897. int loop;
  898. _enter("");
  899. /* we don't know what form we should return non-AFS keys in */
  900. if (memcmp(key->description, "afs@", 4) != 0)
  901. return -EOPNOTSUPP;
  902. cnlen = strlen(key->description + 4);
  903. #define RND(X) (((X) + 3) & ~3)
  904. /* AFS keys we return in XDR form, so we need to work out the size of
  905. * the XDR */
  906. size = 2 * 4; /* flags, cellname len */
  907. size += RND(cnlen); /* cellname */
  908. size += 1 * 4; /* token count */
  909. ntoks = 0;
  910. for (token = key->payload.data[0]; token; token = token->next) {
  911. toksize = 4; /* sec index */
  912. switch (token->security_index) {
  913. case RXRPC_SECURITY_RXKAD:
  914. toksize += 8 * 4; /* viceid, kvno, key*2, begin,
  915. * end, primary, tktlen */
  916. toksize += RND(token->kad->ticket_len);
  917. break;
  918. case RXRPC_SECURITY_RXK5:
  919. princ = &token->k5->client;
  920. toksize += 4 + princ->n_name_parts * 4;
  921. for (loop = 0; loop < princ->n_name_parts; loop++)
  922. toksize += RND(strlen(princ->name_parts[loop]));
  923. toksize += 4 + RND(strlen(princ->realm));
  924. princ = &token->k5->server;
  925. toksize += 4 + princ->n_name_parts * 4;
  926. for (loop = 0; loop < princ->n_name_parts; loop++)
  927. toksize += RND(strlen(princ->name_parts[loop]));
  928. toksize += 4 + RND(strlen(princ->realm));
  929. toksize += 8 + RND(token->k5->session.data_len);
  930. toksize += 4 * 8 + 2 * 4;
  931. toksize += 4 + token->k5->n_addresses * 8;
  932. for (loop = 0; loop < token->k5->n_addresses; loop++)
  933. toksize += RND(token->k5->addresses[loop].data_len);
  934. toksize += 4 + RND(token->k5->ticket_len);
  935. toksize += 4 + RND(token->k5->ticket2_len);
  936. toksize += 4 + token->k5->n_authdata * 8;
  937. for (loop = 0; loop < token->k5->n_authdata; loop++)
  938. toksize += RND(token->k5->authdata[loop].data_len);
  939. break;
  940. default: /* we have a ticket we can't encode */
  941. pr_err("Unsupported key token type (%u)\n",
  942. token->security_index);
  943. return -ENOPKG;
  944. }
  945. _debug("token[%u]: toksize=%u", ntoks, toksize);
  946. ASSERTCMP(toksize, <=, AFSTOKEN_LENGTH_MAX);
  947. toksizes[ntoks++] = toksize;
  948. size += toksize + 4; /* each token has a length word */
  949. }
  950. #undef RND
  951. if (!buffer || buflen < size)
  952. return size;
  953. xdr = (__be32 *)buffer;
  954. zero = 0;
  955. #define ENCODE(x) \
  956. do { \
  957. *xdr++ = htonl(x); \
  958. } while(0)
  959. #define ENCODE_DATA(l, s) \
  960. do { \
  961. u32 _l = (l); \
  962. ENCODE(l); \
  963. memcpy(xdr, (s), _l); \
  964. if (_l & 3) \
  965. memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3)); \
  966. xdr += (_l + 3) >> 2; \
  967. } while(0)
  968. #define ENCODE_BYTES(l, s) \
  969. do { \
  970. u32 _l = (l); \
  971. memcpy(xdr, (s), _l); \
  972. if (_l & 3) \
  973. memcpy((u8 *)xdr + _l, &zero, 4 - (_l & 3)); \
  974. xdr += (_l + 3) >> 2; \
  975. } while(0)
  976. #define ENCODE64(x) \
  977. do { \
  978. __be64 y = cpu_to_be64(x); \
  979. memcpy(xdr, &y, 8); \
  980. xdr += 8 >> 2; \
  981. } while(0)
  982. #define ENCODE_STR(s) \
  983. do { \
  984. const char *_s = (s); \
  985. ENCODE_DATA(strlen(_s), _s); \
  986. } while(0)
  987. ENCODE(0); /* flags */
  988. ENCODE_DATA(cnlen, key->description + 4); /* cellname */
  989. ENCODE(ntoks);
  990. tok = 0;
  991. for (token = key->payload.data[0]; token; token = token->next) {
  992. toksize = toksizes[tok++];
  993. ENCODE(toksize);
  994. oldxdr = xdr;
  995. ENCODE(token->security_index);
  996. switch (token->security_index) {
  997. case RXRPC_SECURITY_RXKAD:
  998. ENCODE(token->kad->vice_id);
  999. ENCODE(token->kad->kvno);
  1000. ENCODE_BYTES(8, token->kad->session_key);
  1001. ENCODE(token->kad->start);
  1002. ENCODE(token->kad->expiry);
  1003. ENCODE(token->kad->primary_flag);
  1004. ENCODE_DATA(token->kad->ticket_len, token->kad->ticket);
  1005. break;
  1006. case RXRPC_SECURITY_RXK5:
  1007. princ = &token->k5->client;
  1008. ENCODE(princ->n_name_parts);
  1009. for (loop = 0; loop < princ->n_name_parts; loop++)
  1010. ENCODE_STR(princ->name_parts[loop]);
  1011. ENCODE_STR(princ->realm);
  1012. princ = &token->k5->server;
  1013. ENCODE(princ->n_name_parts);
  1014. for (loop = 0; loop < princ->n_name_parts; loop++)
  1015. ENCODE_STR(princ->name_parts[loop]);
  1016. ENCODE_STR(princ->realm);
  1017. ENCODE(token->k5->session.tag);
  1018. ENCODE_DATA(token->k5->session.data_len,
  1019. token->k5->session.data);
  1020. ENCODE64(token->k5->authtime);
  1021. ENCODE64(token->k5->starttime);
  1022. ENCODE64(token->k5->endtime);
  1023. ENCODE64(token->k5->renew_till);
  1024. ENCODE(token->k5->is_skey);
  1025. ENCODE(token->k5->flags);
  1026. ENCODE(token->k5->n_addresses);
  1027. for (loop = 0; loop < token->k5->n_addresses; loop++) {
  1028. ENCODE(token->k5->addresses[loop].tag);
  1029. ENCODE_DATA(token->k5->addresses[loop].data_len,
  1030. token->k5->addresses[loop].data);
  1031. }
  1032. ENCODE_DATA(token->k5->ticket_len, token->k5->ticket);
  1033. ENCODE_DATA(token->k5->ticket2_len, token->k5->ticket2);
  1034. ENCODE(token->k5->n_authdata);
  1035. for (loop = 0; loop < token->k5->n_authdata; loop++) {
  1036. ENCODE(token->k5->authdata[loop].tag);
  1037. ENCODE_DATA(token->k5->authdata[loop].data_len,
  1038. token->k5->authdata[loop].data);
  1039. }
  1040. break;
  1041. default:
  1042. pr_err("Unsupported key token type (%u)\n",
  1043. token->security_index);
  1044. return -ENOPKG;
  1045. }
  1046. ASSERTCMP((unsigned long)xdr - (unsigned long)oldxdr, ==,
  1047. toksize);
  1048. }
  1049. #undef ENCODE_STR
  1050. #undef ENCODE_DATA
  1051. #undef ENCODE64
  1052. #undef ENCODE
  1053. ASSERTCMP(tok, ==, ntoks);
  1054. ASSERTCMP((char __user *) xdr - buffer, ==, size);
  1055. _leave(" = %zu", size);
  1056. return size;
  1057. }