1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2008 Doug Rabson
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: stable/12/lib/librpcsec_gss/rpcsec_gss_conf.c 326219 2017-11-26 02:00:33Z pfg $
29 */
30
31 #include <ctype.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #include <errno.h>
36 #include <sys/queue.h>
37 #include <rpc/rpc.h>
38 #include <rpc/rpcsec_gss.h>
39
40 #include "rpcsec_gss_int.h"
41
42 #ifndef _PATH_GSS_MECH
43 #define _PATH_GSS_MECH "/etc/gss/mech"
44 #endif
45
46 #ifndef _PATH_GSS_QOP
47 #define _PATH_GSS_QOP "/etc/gss/qop"
48 #endif
49
50 struct mech_info {
51 SLIST_ENTRY(mech_info) link;
52 char *name;
53 gss_OID_desc oid;
54 const char **qops;
55 char *lib;
56 char *kobj;
57 };
58 SLIST_HEAD(mech_info_list, mech_info);
59
60 static struct mech_info_list mechs = SLIST_HEAD_INITIALIZER(mechs);
61 static const char **mech_names;
62
63 struct qop_info {
64 SLIST_ENTRY(qop_info) link;
65 char *name;
66 char* mech;
67 u_int qop;
68 };
69 SLIST_HEAD(qop_info_list, qop_info);
70
71 static struct qop_info_list qops = SLIST_HEAD_INITIALIZER(qops);
72
73 static int
_rpc_gss_string_to_oid(const char * s,gss_OID oid)74 _rpc_gss_string_to_oid(const char* s, gss_OID oid)
75 {
76 int number_count, i, j;
77 int byte_count;
78 const char *p, *q;
79 char *res;
80
81 /*
82 * First figure out how many numbers in the oid, then
83 * calculate the compiled oid size.
84 */
85 number_count = 0;
86 for (p = s; p; p = q) {
87 q = strchr(p, '.');
88 if (q) q = q + 1;
89 number_count++;
90 }
91
92 /*
93 * The first two numbers are in the first byte and each
94 * subsequent number is encoded in a variable byte sequence.
95 */
96 if (number_count < 2)
97 return (EINVAL);
98
99 /*
100 * We do this in two passes. The first pass, we just figure
101 * out the size. Second time around, we actually encode the
102 * number.
103 */
104 res = 0;
105 for (i = 0; i < 2; i++) {
106 byte_count = 0;
107 for (p = s, j = 0; p; p = q, j++) {
108 u_int number = 0;
109
110 /*
111 * Find the end of this number.
112 */
113 q = strchr(p, '.');
114 if (q) q = q + 1;
115
116 /*
117 * Read the number of of the string. Don't
118 * bother with anything except base ten.
119 */
120 while (*p && *p != '.') {
121 number = 10 * number + (*p - '0');
122 p++;
123 }
124
125 /*
126 * Encode the number. The first two numbers
127 * are packed into the first byte. Subsequent
128 * numbers are encoded in bytes seven bits at
129 * a time with the last byte having the high
130 * bit set.
131 */
132 if (j == 0) {
133 if (res)
134 *res = number * 40;
135 } else if (j == 1) {
136 if (res) {
137 *res += number;
138 res++;
139 }
140 byte_count++;
141 } else if (j >= 2) {
142 /*
143 * The number is encoded in seven bit chunks.
144 */
145 u_int t;
146 int bytes;
147
148 bytes = 0;
149 for (t = number; t; t >>= 7)
150 bytes++;
151 if (bytes == 0) bytes = 1;
152 while (bytes) {
153 if (res) {
154 int bit = 7*(bytes-1);
155
156 *res = (number >> bit) & 0x7f;
157 if (bytes != 1)
158 *res |= 0x80;
159 res++;
160 }
161 byte_count++;
162 bytes--;
163 }
164 }
165 }
166 if (!res) {
167 res = malloc(byte_count);
168 if (!res)
169 return (ENOMEM);
170 oid->length = byte_count;
171 oid->elements = res;
172 }
173 }
174
175 return (0);
176 }
177
178 static void
_rpc_gss_load_mech(void)179 _rpc_gss_load_mech(void)
180 {
181 FILE *fp;
182 char buf[256];
183 char *p;
184 char *name, *oid, *lib, *kobj;
185 struct mech_info *info;
186 int count;
187 const char **pp;
188
189 if (SLIST_FIRST(&mechs))
190 return;
191
192 fp = fopen(_PATH_GSS_MECH, "r");
193 if (!fp)
194 return;
195
196 count = 0;
197 while (fgets(buf, sizeof(buf), fp)) {
198 if (*buf == '#')
199 continue;
200 p = buf;
201 name = strsep(&p, "\t\n ");
202 if (p) while (isspace(*p)) p++;
203 oid = strsep(&p, "\t\n ");
204 if (p) while (isspace(*p)) p++;
205 lib = strsep(&p, "\t\n ");
206 if (p) while (isspace(*p)) p++;
207 kobj = strsep(&p, "\t\n ");
208 if (!name || !oid || !lib || !kobj)
209 continue;
210
211 info = malloc(sizeof(struct mech_info));
212 if (!info)
213 break;
214 if (_rpc_gss_string_to_oid(oid, &info->oid)) {
215 free(info);
216 continue;
217 }
218 info->name = strdup(name);
219 info->qops = NULL;
220 info->lib = strdup(lib);
221 info->kobj = strdup(kobj);
222 SLIST_INSERT_HEAD(&mechs, info, link);
223 count++;
224 }
225 fclose(fp);
226
227 mech_names = malloc((count + 1) * sizeof(char*));
228 pp = mech_names;
229 SLIST_FOREACH(info, &mechs, link) {
230 *pp++ = info->name;
231 }
232 *pp = NULL;
233 }
234
235 static void
_rpc_gss_load_qop(void)236 _rpc_gss_load_qop(void)
237 {
238 FILE *fp;
239 char buf[256];
240 char *p;
241 char *name, *num, *mech;
242 struct mech_info *minfo;
243 struct qop_info *info;
244 int count;
245 const char **mech_qops;
246 const char **pp;
247
248 if (SLIST_FIRST(&qops))
249 return;
250
251 fp = fopen(_PATH_GSS_QOP, "r");
252 if (!fp)
253 return;
254
255 while (fgets(buf, sizeof(buf), fp)) {
256 if (*buf == '#')
257 continue;
258 p = buf;
259 name = strsep(&p, "\t\n ");
260 if (p) while (isspace(*p)) p++;
261 num = strsep(&p, "\t\n ");
262 if (p) while (isspace(*p)) p++;
263 mech = strsep(&p, "\t\n ");
264 if (!name || !num || !mech)
265 continue;
266
267 info = malloc(sizeof(struct qop_info));
268 if (!info)
269 break;
270 info->name = strdup(name);
271 info->qop = strtoul(name, 0, 0);
272 info->mech = strdup(mech);
273 SLIST_INSERT_HEAD(&qops, info, link);
274 }
275 fclose(fp);
276
277 /*
278 * Compile lists of qops for each mechanism.
279 */
280 SLIST_FOREACH(minfo, &mechs, link) {
281 count = 0;
282 SLIST_FOREACH(info, &qops, link) {
283 if (strcmp(info->mech, minfo->name) == 0)
284 count++;
285 }
286 mech_qops = malloc((count + 1) * sizeof(char*));
287 pp = mech_qops;
288 SLIST_FOREACH(info, &qops, link) {
289 if (strcmp(info->mech, minfo->name) == 0)
290 *pp++ = info->name;
291 }
292 *pp = NULL;
293 minfo->qops = mech_qops;
294 }
295 }
296
297 bool_t
rpc_gss_mech_to_oid(const char * mech,gss_OID * oid_ret)298 rpc_gss_mech_to_oid(const char *mech, gss_OID *oid_ret)
299 {
300 struct mech_info *info;
301
302 _rpc_gss_load_mech();
303 SLIST_FOREACH(info, &mechs, link) {
304 if (!strcmp(info->name, mech)) {
305 *oid_ret = &info->oid;
306 return (TRUE);
307 }
308 }
309 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
310 return (FALSE);
311 }
312
313 bool_t
rpc_gss_oid_to_mech(gss_OID oid,const char ** mech_ret)314 rpc_gss_oid_to_mech(gss_OID oid, const char **mech_ret)
315 {
316 struct mech_info *info;
317
318 _rpc_gss_load_mech();
319 SLIST_FOREACH(info, &mechs, link) {
320 if (oid->length == info->oid.length
321 && !memcmp(oid->elements, info->oid.elements,
322 oid->length)) {
323 *mech_ret = info->name;
324 return (TRUE);
325 }
326 }
327 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
328 return (FALSE);
329 }
330
331 bool_t
rpc_gss_qop_to_num(const char * qop,const char * mech,u_int * num_ret)332 rpc_gss_qop_to_num(const char *qop, const char *mech, u_int *num_ret)
333 {
334 struct qop_info *info;
335
336 _rpc_gss_load_qop();
337 SLIST_FOREACH(info, &qops, link) {
338 if (strcmp(info->name, qop) == 0
339 && strcmp(info->mech, mech) == 0) {
340 *num_ret = info->qop;
341 return (TRUE);
342 }
343 }
344 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
345 return (FALSE);
346 }
347
348 const char *
_rpc_gss_num_to_qop(const char * mech,u_int num)349 _rpc_gss_num_to_qop(const char *mech, u_int num)
350 {
351 struct qop_info *info;
352
353 if (num == GSS_C_QOP_DEFAULT)
354 return "default";
355
356 _rpc_gss_load_qop();
357 SLIST_FOREACH(info, &qops, link) {
358 if (info->qop == num && strcmp(info->mech, mech) == 0) {
359 return (info->name);
360 }
361 }
362 return (NULL);
363 }
364
365 const char **
rpc_gss_get_mechanisms(void)366 rpc_gss_get_mechanisms(void)
367 {
368
369 _rpc_gss_load_mech();
370 return (mech_names);
371 }
372
373 const char **
rpc_gss_get_mech_info(const char * mech,rpc_gss_service_t * service)374 rpc_gss_get_mech_info(const char *mech, rpc_gss_service_t *service)
375 {
376 struct mech_info *info;
377
378 _rpc_gss_load_mech();
379 _rpc_gss_load_qop();
380 SLIST_FOREACH(info, &mechs, link) {
381 if (!strcmp(mech, info->name)) {
382 /*
383 * I'm not sure what to do with service
384 * here. The Solaris manpages are not clear on
385 * the subject and the OpenSolaris code just
386 * sets it to rpc_gss_svc_privacy
387 * unconditionally with a comment noting that
388 * it is bogus.
389 */
390 *service = rpc_gss_svc_privacy;
391 return info->qops;
392 }
393 }
394
395 _rpc_gss_set_error(RPC_GSS_ER_SYSTEMERROR, ENOENT);
396 return (NULL);
397 }
398
399 bool_t
rpc_gss_get_versions(u_int * vers_hi,u_int * vers_lo)400 rpc_gss_get_versions(u_int *vers_hi, u_int *vers_lo)
401 {
402
403 *vers_hi = 1;
404 *vers_lo = 1;
405 return (TRUE);
406 }
407
408 bool_t
rpc_gss_is_installed(const char * mech)409 rpc_gss_is_installed(const char *mech)
410 {
411 struct mech_info *info;
412
413 _rpc_gss_load_mech();
414 SLIST_FOREACH(info, &mechs, link)
415 if (!strcmp(mech, info->name))
416 return (TRUE);
417 return (FALSE);
418 }
419
420