Branch data Line data Source code
1 : : /* Key type used to cache DNS lookups made by the kernel
2 : : *
3 : : * See Documentation/networking/dns_resolver.txt
4 : : *
5 : : * Copyright (c) 2007 Igor Mammedov
6 : : * Author(s): Igor Mammedov (niallain@gmail.com)
7 : : * Steve French (sfrench@us.ibm.com)
8 : : * Wang Lei (wang840925@gmail.com)
9 : : * David Howells (dhowells@redhat.com)
10 : : *
11 : : * This library is free software; you can redistribute it and/or modify
12 : : * it under the terms of the GNU Lesser General Public License as published
13 : : * by the Free Software Foundation; either version 2.1 of the License, or
14 : : * (at your option) any later version.
15 : : *
16 : : * This library is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
19 : : * the GNU Lesser General Public License for more details.
20 : : *
21 : : * You should have received a copy of the GNU Lesser General Public License
22 : : * along with this library; if not, see <http://www.gnu.org/licenses/>.
23 : : */
24 : : #include <linux/module.h>
25 : : #include <linux/moduleparam.h>
26 : : #include <linux/slab.h>
27 : : #include <linux/string.h>
28 : : #include <linux/kernel.h>
29 : : #include <linux/keyctl.h>
30 : : #include <linux/err.h>
31 : : #include <linux/seq_file.h>
32 : : #include <keys/dns_resolver-type.h>
33 : : #include <keys/user-type.h>
34 : : #include "internal.h"
35 : :
36 : : MODULE_DESCRIPTION("DNS Resolver");
37 : : MODULE_AUTHOR("Wang Lei");
38 : : MODULE_LICENSE("GPL");
39 : :
40 : : unsigned int dns_resolver_debug;
41 : : module_param_named(debug, dns_resolver_debug, uint, S_IWUSR | S_IRUGO);
42 : : MODULE_PARM_DESC(debug, "DNS Resolver debugging mask");
43 : :
44 : : const struct cred *dns_resolver_cache;
45 : :
46 : : #define DNS_ERRORNO_OPTION "dnserror"
47 : :
48 : : /*
49 : : * Instantiate a user defined key for dns_resolver.
50 : : *
51 : : * The data must be a NUL-terminated string, with the NUL char accounted in
52 : : * datalen.
53 : : *
54 : : * If the data contains a '#' characters, then we take the clause after each
55 : : * one to be an option of the form 'key=value'. The actual data of interest is
56 : : * the string leading up to the first '#'. For instance:
57 : : *
58 : : * "ip1,ip2,...#foo=bar"
59 : : */
60 : : static int
61 : 0 : dns_resolver_instantiate(struct key *key, struct key_preparsed_payload *prep)
62 : : {
63 : : struct user_key_payload *upayload;
64 : : unsigned long derrno;
65 : : int ret;
66 : 0 : size_t datalen = prep->datalen, result_len = 0;
67 : 0 : const char *data = prep->data, *end, *opt;
68 : :
69 [ # # ]: 0 : kenter("%%%d,%s,'%*.*s',%zu",
70 : : key->serial, key->description,
71 : : (int)datalen, (int)datalen, data, datalen);
72 : :
73 [ # # ][ # # ]: 0 : if (datalen <= 1 || !data || data[datalen - 1] != '\0')
74 : : return -EINVAL;
75 : : datalen--;
76 : :
77 : : /* deal with any options embedded in the data */
78 : : end = data + datalen;
79 : 0 : opt = memchr(data, '#', datalen);
80 [ # # ]: 0 : if (!opt) {
81 : : /* no options: the entire data is the result */
82 [ # # ]: 0 : kdebug("no options");
83 : : result_len = datalen;
84 : : } else {
85 : : const char *next_opt;
86 : :
87 : 0 : result_len = opt - data;
88 : 0 : opt++;
89 [ # # ]: 0 : kdebug("options: '%s'", opt);
90 : : do {
91 : : const char *eq;
92 : : int opt_len, opt_nlen, opt_vlen, tmp;
93 : :
94 [ # # ]: 0 : next_opt = memchr(opt, '#', end - opt) ?: end;
95 : 0 : opt_len = next_opt - opt;
96 [ # # ]: 0 : if (!opt_len) {
97 : 0 : printk(KERN_WARNING
98 : : "Empty option to dns_resolver key %d\n",
99 : : key->serial);
100 : 0 : return -EINVAL;
101 : : }
102 : :
103 [ # # ]: 0 : eq = memchr(opt, '=', opt_len) ?: end;
104 : 0 : opt_nlen = eq - opt;
105 : 0 : eq++;
106 : 0 : opt_vlen = next_opt - eq; /* will be -1 if no value */
107 : :
108 : 0 : tmp = opt_vlen >= 0 ? opt_vlen : 0;
109 [ # # ]: 0 : kdebug("option '%*.*s' val '%*.*s'",
110 : : opt_nlen, opt_nlen, opt, tmp, tmp, eq);
111 : :
112 : : /* see if it's an error number representing a DNS error
113 : : * that's to be recorded as the result in this key */
114 [ # # ][ # # ]: 0 : if (opt_nlen == sizeof(DNS_ERRORNO_OPTION) - 1 &&
115 : 0 : memcmp(opt, DNS_ERRORNO_OPTION, opt_nlen) == 0) {
116 [ # # ]: 0 : kdebug("dns error number option");
117 [ # # ]: 0 : if (opt_vlen <= 0)
118 : : goto bad_option_value;
119 : :
120 : : ret = kstrtoul(eq, 10, &derrno);
121 [ # # ]: 0 : if (ret < 0)
122 : : goto bad_option_value;
123 : :
124 [ # # ]: 0 : if (derrno < 1 || derrno > 511)
125 : : goto bad_option_value;
126 : :
127 [ # # ]: 0 : kdebug("dns error no. = %lu", derrno);
128 : 0 : key->type_data.x[0] = -derrno;
129 : 0 : continue;
130 : : }
131 : :
132 : : bad_option_value:
133 : 0 : printk(KERN_WARNING
134 : : "Option '%*.*s' to dns_resolver key %d:"
135 : : " bad/missing value\n",
136 : : opt_nlen, opt_nlen, opt, key->serial);
137 : 0 : return -EINVAL;
138 [ # # ]: 0 : } while (opt = next_opt + 1, opt < end);
139 : : }
140 : :
141 : : /* don't cache the result if we're caching an error saying there's no
142 : : * result */
143 [ # # ]: 0 : if (key->type_data.x[0]) {
144 [ # # ]: 0 : kleave(" = 0 [h_error %ld]", key->type_data.x[0]);
145 : : return 0;
146 : : }
147 : :
148 [ # # ]: 0 : kdebug("store result");
149 : 0 : ret = key_payload_reserve(key, result_len);
150 [ # # ]: 0 : if (ret < 0)
151 : : return -EINVAL;
152 : :
153 : 0 : upayload = kmalloc(sizeof(*upayload) + result_len + 1, GFP_KERNEL);
154 [ # # ]: 0 : if (!upayload) {
155 [ # # ]: 0 : kleave(" = -ENOMEM");
156 : : return -ENOMEM;
157 : : }
158 : :
159 : 0 : upayload->datalen = result_len;
160 : 0 : memcpy(upayload->data, data, result_len);
161 : 0 : upayload->data[result_len] = '\0';
162 : 0 : rcu_assign_pointer(key->payload.data, upayload);
163 : :
164 [ # # ]: 0 : kleave(" = 0");
165 : : return 0;
166 : : }
167 : :
168 : : /*
169 : : * The description is of the form "[<type>:]<domain_name>"
170 : : *
171 : : * The domain name may be a simple name or an absolute domain name (which
172 : : * should end with a period). The domain name is case-independent.
173 : : */
174 : : static int
175 : 0 : dns_resolver_match(const struct key *key, const void *description)
176 : : {
177 : : int slen, dlen, ret = 0;
178 : 0 : const char *src = key->description, *dsp = description;
179 : :
180 [ # # ]: 0 : kenter("%s,%s", src, dsp);
181 : :
182 [ # # ]: 0 : if (!src || !dsp)
183 : : goto no_match;
184 : :
185 [ # # ]: 0 : if (strcasecmp(src, dsp) == 0)
186 : : goto matched;
187 : :
188 : 0 : slen = strlen(src);
189 : 0 : dlen = strlen(dsp);
190 [ # # ]: 0 : if (slen <= 0 || dlen <= 0)
191 : : goto no_match;
192 [ # # ]: 0 : if (src[slen - 1] == '.')
193 : 0 : slen--;
194 [ # # ]: 0 : if (dsp[dlen - 1] == '.')
195 : 0 : dlen--;
196 [ # # ][ # # ]: 0 : if (slen != dlen || strncasecmp(src, dsp, slen) != 0)
197 : : goto no_match;
198 : :
199 : : matched:
200 : : ret = 1;
201 : : no_match:
202 [ # # ]: 0 : kleave(" = %d", ret);
203 : 0 : return ret;
204 : : }
205 : :
206 : : /*
207 : : * Describe a DNS key
208 : : */
209 : 0 : static void dns_resolver_describe(const struct key *key, struct seq_file *m)
210 : : {
211 : 0 : int err = key->type_data.x[0];
212 : :
213 : 0 : seq_puts(m, key->description);
214 [ # # ]: 0 : if (key_is_instantiated(key)) {
215 [ # # ]: 0 : if (err)
216 : 0 : seq_printf(m, ": %d", err);
217 : : else
218 : 0 : seq_printf(m, ": %u", key->datalen);
219 : : }
220 : 0 : }
221 : :
222 : : /*
223 : : * read the DNS data
224 : : * - the key's semaphore is read-locked
225 : : */
226 : 0 : static long dns_resolver_read(const struct key *key,
227 : : char __user *buffer, size_t buflen)
228 : : {
229 [ # # ]: 0 : if (key->type_data.x[0])
230 : 0 : return key->type_data.x[0];
231 : :
232 : 0 : return user_read(key, buffer, buflen);
233 : : }
234 : :
235 : : struct key_type key_type_dns_resolver = {
236 : : .name = "dns_resolver",
237 : : .instantiate = dns_resolver_instantiate,
238 : : .match = dns_resolver_match,
239 : : .revoke = user_revoke,
240 : : .destroy = user_destroy,
241 : : .describe = dns_resolver_describe,
242 : : .read = dns_resolver_read,
243 : : };
244 : :
245 : 0 : static int __init init_dns_resolver(void)
246 : : {
247 : : struct cred *cred;
248 : : struct key *keyring;
249 : : int ret;
250 : :
251 : : /* create an override credential set with a special thread keyring in
252 : : * which DNS requests are cached
253 : : *
254 : : * this is used to prevent malicious redirections from being installed
255 : : * with add_key().
256 : : */
257 : 0 : cred = prepare_kernel_cred(NULL);
258 [ # # ]: 0 : if (!cred)
259 : : return -ENOMEM;
260 : :
261 : 0 : keyring = keyring_alloc(".dns_resolver",
262 : 0 : GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, cred,
263 : : (KEY_POS_ALL & ~KEY_POS_SETATTR) |
264 : : KEY_USR_VIEW | KEY_USR_READ,
265 : : KEY_ALLOC_NOT_IN_QUOTA, NULL);
266 [ # # ]: 0 : if (IS_ERR(keyring)) {
267 : : ret = PTR_ERR(keyring);
268 : 0 : goto failed_put_cred;
269 : : }
270 : :
271 : 0 : ret = register_key_type(&key_type_dns_resolver);
272 [ # # ]: 0 : if (ret < 0)
273 : : goto failed_put_key;
274 : :
275 : : /* instruct request_key() to use this special keyring as a cache for
276 : : * the results it looks up */
277 : 0 : set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags);
278 : 0 : cred->thread_keyring = keyring;
279 : 0 : cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING;
280 : 0 : dns_resolver_cache = cred;
281 : :
282 [ # # ]: 0 : kdebug("DNS resolver keyring: %d\n", key_serial(keyring));
283 : : return 0;
284 : :
285 : : failed_put_key:
286 : 0 : key_put(keyring);
287 : : failed_put_cred:
288 : : put_cred(cred);
289 : 0 : return ret;
290 : : }
291 : :
292 : 0 : static void __exit exit_dns_resolver(void)
293 : : {
294 : 0 : key_revoke(dns_resolver_cache->thread_keyring);
295 : 0 : unregister_key_type(&key_type_dns_resolver);
296 : 0 : put_cred(dns_resolver_cache);
297 : 0 : }
298 : :
299 : : module_init(init_dns_resolver)
300 : : module_exit(exit_dns_resolver)
301 : : MODULE_LICENSE("GPL");
302 : :
|
