source: rtems/cpukit/librpc/src/rpc/key_call.c @ df49c60

4.104.114.84.9
Last change on this file since df49c60 was df49c60, checked in by Joel Sherrill <joel.sherrill@…>, on Jun 12, 2000 at 3:00:15 PM

Merged from 4.5.0-beta3a

  • Property mode set to 100644
File size: 10.4 KB
Line 
1/*
2 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
3 * unrestricted use provided that this legend is included on all tape
4 * media and as a part of the software program in whole or part.  Users
5 * may copy or modify Sun RPC without charge, but are not authorized
6 * to license or distribute it to anyone else except as part of a product or
7 * program developed by the user.
8 *
9 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
10 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
11 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
12 *
13 * Sun RPC is provided with no support and without any obligation on the
14 * part of Sun Microsystems, Inc. to assist in its use, correction,
15 * modification or enhancement.
16 *
17 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
18 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
19 * OR ANY PART THEREOF.
20 *
21 * In no event will Sun Microsystems, Inc. be liable for any lost revenue
22 * or profits or other special, indirect and consequential damages, even if
23 * Sun has been advised of the possibility of such damages.
24 *
25 * Sun Microsystems, Inc.
26 * 2550 Garcia Avenue
27 * Mountain View, California  94043
28 */
29/*
30 * Copyright (c) 1986-1991 by Sun Microsystems Inc.
31 *
32 * $FreeBSD: src/lib/libc/rpc/key_call.c,v 1.3 2000/01/27 23:06:39 jasone Exp $
33 */
34
35#ident  "@(#)key_call.c 1.25    94/04/24 SMI"
36
37/*
38 * key_call.c, Interface to keyserver
39 *
40 * setsecretkey(key) - set your secret key
41 * encryptsessionkey(agent, deskey) - encrypt a session key to talk to agent
42 * decryptsessionkey(agent, deskey) - decrypt ditto
43 * gendeskey(deskey) - generate a secure des key
44 */
45
46#include <stdio.h>
47#include <stdlib.h>
48#include <unistd.h>
49#include <errno.h>
50#include <rpc/rpc.h>
51#include <rpc/auth.h>
52#include <rpc/auth_unix.h>
53#include <rpc/key_prot.h>
54#include <string.h>
55#include <sys/utsname.h>
56#include <stdlib.h>
57#include <signal.h>
58#include <sys/wait.h>
59#include <sys/fcntl.h>
60
61
62#define KEY_TIMEOUT     5       /* per-try timeout in seconds */
63#define KEY_NRETRY      12      /* number of retries */
64
65#ifdef DEBUG
66#define debug(msg)      (void) fprintf(stderr, "%s\n", msg);
67#else
68#define debug(msg)
69#endif /* DEBUG */
70
71/*
72 * Hack to allow the keyserver to use AUTH_DES (for authenticated
73 * NIS+ calls, for example).  The only functions that get called
74 * are key_encryptsession_pk, key_decryptsession_pk, and key_gendes.
75 *
76 * The approach is to have the keyserver fill in pointers to local
77 * implementations of these functions, and to call those in key_call().
78 */
79
80cryptkeyres *(*__key_encryptsession_pk_LOCAL)() = 0;
81cryptkeyres *(*__key_decryptsession_pk_LOCAL)() = 0;
82des_block *(*__key_gendes_LOCAL)() = 0;
83
84static int key_call __P(( u_long, xdrproc_t, char *, xdrproc_t, char * ));
85
86int
87key_setsecret(secretkey)
88        const char *secretkey;
89{
90        keystatus status;
91
92        if (!key_call((u_long) KEY_SET, xdr_keybuf, (char *) secretkey,
93                        xdr_keystatus, (char *)&status)) {
94                return (-1);
95        }
96        if (status != KEY_SUCCESS) {
97                debug("set status is nonzero");
98                return (-1);
99        }
100        return (0);
101}
102
103
104/* key_secretkey_is_set() returns 1 if the keyserver has a secret key
105 * stored for the caller's effective uid; it returns 0 otherwise
106 *
107 * N.B.:  The KEY_NET_GET key call is undocumented.  Applications shouldn't
108 * be using it, because it allows them to get the user's secret key.
109 */
110
111int
112key_secretkey_is_set(void)
113{
114        struct key_netstres     kres;
115
116        memset((void*)&kres, 0, sizeof (kres));
117        if (key_call((u_long) KEY_NET_GET, xdr_void, (char *)NULL,
118                        xdr_key_netstres, (char *) &kres) &&
119            (kres.status == KEY_SUCCESS) &&
120            (kres.key_netstres_u.knet.st_priv_key[0] != 0)) {
121                /* avoid leaving secret key in memory */
122                memset(kres.key_netstres_u.knet.st_priv_key, 0, HEXKEYBYTES);
123                return (1);
124        }
125        return (0);
126}
127
128int
129key_encryptsession_pk(remotename, remotekey, deskey)
130        char *remotename;
131        netobj *remotekey;
132        des_block *deskey;
133{
134        cryptkeyarg2 arg;
135        cryptkeyres res;
136
137        arg.remotename = remotename;
138        arg.remotekey = *remotekey;
139        arg.deskey = *deskey;
140        if (!key_call((u_long)KEY_ENCRYPT_PK, xdr_cryptkeyarg2, (char *)&arg,
141                        xdr_cryptkeyres, (char *)&res)) {
142                return (-1);
143        }
144        if (res.status != KEY_SUCCESS) {
145                debug("encrypt status is nonzero");
146                return (-1);
147        }
148        *deskey = res.cryptkeyres_u.deskey;
149        return (0);
150}
151
152int
153key_decryptsession_pk(remotename, remotekey, deskey)
154        char *remotename;
155        netobj *remotekey;
156        des_block *deskey;
157{
158        cryptkeyarg2 arg;
159        cryptkeyres res;
160
161        arg.remotename = remotename;
162        arg.remotekey = *remotekey;
163        arg.deskey = *deskey;
164        if (!key_call((u_long)KEY_DECRYPT_PK, xdr_cryptkeyarg2, (char *)&arg,
165                        xdr_cryptkeyres, (char *)&res)) {
166                return (-1);
167        }
168        if (res.status != KEY_SUCCESS) {
169                debug("decrypt status is nonzero");
170                return (-1);
171        }
172        *deskey = res.cryptkeyres_u.deskey;
173        return (0);
174}
175
176int
177key_encryptsession(remotename, deskey)
178        const char *remotename;
179        des_block *deskey;
180{
181        cryptkeyarg arg;
182        cryptkeyres res;
183
184        arg.remotename = (char *) remotename;
185        arg.deskey = *deskey;
186        if (!key_call((u_long)KEY_ENCRYPT, xdr_cryptkeyarg, (char *)&arg,
187                        xdr_cryptkeyres, (char *)&res)) {
188                return (-1);
189        }
190        if (res.status != KEY_SUCCESS) {
191                debug("encrypt status is nonzero");
192                return (-1);
193        }
194        *deskey = res.cryptkeyres_u.deskey;
195        return (0);
196}
197
198int
199key_decryptsession(remotename, deskey)
200        const char *remotename;
201        des_block *deskey;
202{
203        cryptkeyarg arg;
204        cryptkeyres res;
205
206        arg.remotename = (char *) remotename;
207        arg.deskey = *deskey;
208        if (!key_call((u_long)KEY_DECRYPT, xdr_cryptkeyarg, (char *)&arg,
209                        xdr_cryptkeyres, (char *)&res)) {
210                return (-1);
211        }
212        if (res.status != KEY_SUCCESS) {
213                debug("decrypt status is nonzero");
214                return (-1);
215        }
216        *deskey = res.cryptkeyres_u.deskey;
217        return (0);
218}
219
220int
221key_gendes(key)
222        des_block *key;
223{
224        if (!key_call((u_long)KEY_GEN, xdr_void, (char *)NULL,
225                        xdr_des_block, (char *)key)) {
226                return (-1);
227        }
228        return (0);
229}
230
231int
232key_setnet(arg)
233struct netstarg *arg;
234{
235        keystatus status;
236
237
238        if (!key_call((u_long) KEY_NET_PUT, xdr_key_netstarg, (char *) arg,
239                xdr_keystatus, (char *) &status)){
240                return (-1);
241        }
242
243        if (status != KEY_SUCCESS) {
244                debug("key_setnet status is nonzero");
245                return (-1);
246        }
247        return (1);
248}
249
250
251int
252key_get_conv(pkey, deskey)
253        char *pkey;
254        des_block *deskey;
255{
256        cryptkeyres res;
257
258        if (!key_call((u_long) KEY_GET_CONV, xdr_keybuf, pkey,
259                xdr_cryptkeyres, (char *)&res)) {
260                return (-1);
261        }
262        if (res.status != KEY_SUCCESS) {
263                debug("get_conv status is nonzero");
264                return (-1);
265        }
266        *deskey = res.cryptkeyres_u.deskey;
267        return (0);
268}
269
270struct  key_call_private {
271        CLIENT  *client;        /* Client handle */
272        pid_t   pid;            /* process-id at moment of creation */
273        uid_t   uid;            /* user-id at last authorization */
274};
275static struct key_call_private *key_call_private_main = NULL;
276
277#ifdef foo
278static void
279key_call_destroy(void *vp)
280{
281        register struct key_call_private *kcp = (struct key_call_private *)vp;
282
283        if (kcp) {
284                if (kcp->client)
285                        clnt_destroy(kcp->client);
286                free(kcp);
287        }
288}
289#endif
290
291/*
292 * Keep the handle cached.  This call may be made quite often.
293 */
294static CLIENT *
295getkeyserv_handle(vers)
296int     vers;
297{
298        struct key_call_private *kcp = key_call_private_main;
299        struct timeval wait_time;
300        int fd;
301        struct sockaddr_un name;
302        int namelen = sizeof(struct sockaddr_un);
303
304#define TOTAL_TIMEOUT   30      /* total timeout talking to keyserver */
305#define TOTAL_TRIES     5       /* Number of tries */
306
307        if (kcp == (struct key_call_private *)NULL) {
308                kcp = (struct key_call_private *)malloc(sizeof (*kcp));
309                if (kcp == (struct key_call_private *)NULL) {
310                        return ((CLIENT *) NULL);
311                }
312                key_call_private_main = kcp;
313                kcp->client = NULL;
314        }
315
316        /* if pid has changed, destroy client and rebuild */
317        if (kcp->client != NULL && kcp->pid != getpid()) {
318                clnt_destroy(kcp->client);
319                kcp->client = NULL;
320        }
321
322        if (kcp->client != NULL) {
323                /* if other side closed socket, build handle again */
324                clnt_control(kcp->client, CLGET_FD, (char *)&fd);
325                if (getpeername(fd,(struct sockaddr *)&name,&namelen) == -1) {
326                        auth_destroy(kcp->client->cl_auth);
327                        clnt_destroy(kcp->client);
328                        kcp->client = NULL;
329                }
330        }
331
332        if (kcp->client != NULL) {
333                /* if uid has changed, build client handle again */
334                if (kcp->uid != geteuid()) {
335                        kcp->uid = geteuid();
336                        auth_destroy(kcp->client->cl_auth);
337                        kcp->client->cl_auth =
338                                authsys_create("", kcp->uid, 0, 0, NULL);
339                        if (kcp->client->cl_auth == NULL) {
340                                clnt_destroy(kcp->client);
341                                kcp->client = NULL;
342                                return ((CLIENT *) NULL);
343                        }
344                }
345                /* Change the version number to the new one */
346                clnt_control(kcp->client, CLSET_VERS, (void *)&vers);
347                return (kcp->client);
348        }
349
350        if ((kcp->client == (CLIENT *) NULL))
351                /* Use the AF_UNIX transport */
352                kcp->client = clnt_create("/var/run/keyservsock", KEY_PROG,
353                                                        vers, "unix");
354
355        if (kcp->client == (CLIENT *) NULL) {
356                return ((CLIENT *) NULL);
357        }
358        kcp->uid = geteuid();
359        kcp->pid = getpid();
360        kcp->client->cl_auth = authsys_create("", kcp->uid, 0, 0, NULL);
361        if (kcp->client->cl_auth == NULL) {
362                clnt_destroy(kcp->client);
363                kcp->client = NULL;
364                return ((CLIENT *) NULL);
365        }
366
367        wait_time.tv_sec = TOTAL_TIMEOUT/TOTAL_TRIES;
368        wait_time.tv_usec = 0;
369        (void) clnt_control(kcp->client, CLSET_RETRY_TIMEOUT,
370                (char *)&wait_time);
371        if (clnt_control(kcp->client, CLGET_FD, (char *)&fd))
372                _fcntl(fd, F_SETFD, 1); /* make it "close on exec" */
373
374        return (kcp->client);
375}
376
377/* returns  0 on failure, 1 on success */
378
379static int
380key_call(proc, xdr_arg, arg, xdr_rslt, rslt)
381        u_long proc;
382        xdrproc_t xdr_arg;
383        char *arg;
384        xdrproc_t xdr_rslt;
385        char *rslt;
386{
387        CLIENT *clnt;
388        struct timeval wait_time;
389
390        if (proc == KEY_ENCRYPT_PK && __key_encryptsession_pk_LOCAL) {
391                cryptkeyres *res;
392                res = (*__key_encryptsession_pk_LOCAL)(geteuid(), arg);
393                *(cryptkeyres*)rslt = *res;
394                return (1);
395        } else if (proc == KEY_DECRYPT_PK && __key_decryptsession_pk_LOCAL) {
396                cryptkeyres *res;
397                res = (*__key_decryptsession_pk_LOCAL)(geteuid(), arg);
398                *(cryptkeyres*)rslt = *res;
399                return (1);
400        } else if (proc == KEY_GEN && __key_gendes_LOCAL) {
401                des_block *res;
402                res = (*__key_gendes_LOCAL)(geteuid(), 0);
403                *(des_block*)rslt = *res;
404                return (1);
405        }
406
407        if ((proc == KEY_ENCRYPT_PK) || (proc == KEY_DECRYPT_PK) ||
408            (proc == KEY_NET_GET) || (proc == KEY_NET_PUT) ||
409            (proc == KEY_GET_CONV))
410                clnt = getkeyserv_handle(2); /* talk to version 2 */
411        else
412                clnt = getkeyserv_handle(1); /* talk to version 1 */
413
414        if (clnt == NULL) {
415                return (0);
416        }
417
418        wait_time.tv_sec = TOTAL_TIMEOUT;
419        wait_time.tv_usec = 0;
420
421        if (clnt_call(clnt, proc, xdr_arg, arg, xdr_rslt, rslt,
422                wait_time) == RPC_SUCCESS) {
423                return (1);
424        } else {
425                return (0);
426        }
427}
Note: See TracBrowser for help on using the repository browser.