lib/libc/rpc/key_call.c

   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
  33 #ident  "@(#)key_call.c 1.25    94/04/24 SMI"
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  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 "namespace.h"
  47 #include "reentrant.h"
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <unistd.h>
  51 #include <errno.h>
  52 #include <rpc/rpc.h>
  53 #include <rpc/auth.h>
  54 #include <rpc/auth_unix.h>
  55 #include <rpc/key_prot.h>
  56 #include <string.h>
  57 #include <netconfig.h>
  58 #include <sys/utsname.h>
  59 #include <stdlib.h>
  60 #include <signal.h>
  61 #include <sys/wait.h>
  62 #include <sys/fcntl.h>
  63 #include "un-namespace.h"
  64 #include "mt_misc.h"
  65
  66
  67 #define KEY_TIMEOUT     5       /* per-try timeout in seconds */
  68 #define KEY_NRETRY      12      /* number of retries */
  69
  70 #ifdef DEBUG
  71 #define debug(msg)      (void) fprintf(stderr, "%s\n", msg);
  72 #else
  73 #define debug(msg)
  74 #endif /* DEBUG */
  75
  76 /*
  77  * Hack to allow the keyserver to use AUTH_DES (for authenticated
  78  * NIS+ calls, for example).  The only functions that get called
  79  * are key_encryptsession_pk, key_decryptsession_pk, and key_gendes.
  80  *
  81  * The approach is to have the keyserver fill in pointers to local
  82  * implementations of these functions, and to call those in key_call().
  83  */
  84
  85 cryptkeyres *(*__key_encryptsession_pk_LOCAL)() = 0;
  86 cryptkeyres *(*__key_decryptsession_pk_LOCAL)() = 0;
  87 des_block *(*__key_gendes_LOCAL)() = 0;
  88
  89 static int key_call( u_long, xdrproc_t, void *, xdrproc_t, void *);
  90
  91 int
  92 key_setsecret(secretkey)
  93         const char *secretkey;
  94 {
  95         keystatus status;
  96
  97         if (!key_call((u_long) KEY_SET, (xdrproc_t)xdr_keybuf,
  98                         (void *)secretkey,
  99                         (xdrproc_t)xdr_keystatus, &status)) {
 100                 return (-1);
 101         }
 102         if (status != KEY_SUCCESS) {
 103                 debug("set status is nonzero");
 104                 return (-1);
 105         }
 106         return (0);
 107 }
 108
 109
 110 /* key_secretkey_is_set() returns 1 if the keyserver has a secret key
 111  * stored for the caller's effective uid; it returns 0 otherwise
 112  *
 113  * N.B.:  The KEY_NET_GET key call is undocumented.  Applications shouldn't
 114  * be using it, because it allows them to get the user's secret key.
 115  */
 116
 117 int
 118 key_secretkey_is_set(void)
 119 {
 120         struct key_netstres     kres;
 121
 122         memset((void*)&kres, 0, sizeof (kres));
 123         if (key_call((u_long) KEY_NET_GET, (xdrproc_t)xdr_void, NULL,
 124                         (xdrproc_t)xdr_key_netstres, &kres) &&
 125             (kres.status == KEY_SUCCESS) &&
 126             (kres.key_netstres_u.knet.st_priv_key[0] != 0)) {
 127                 /* avoid leaving secret key in memory */
 128                 memset(kres.key_netstres_u.knet.st_priv_key, 0, HEXKEYBYTES);
 129                 return (1);
 130         }
 131         return (0);
 132 }
 133
 134 int
 135 key_encryptsession_pk(remotename, remotekey, deskey)
 136         char *remotename;
 137         netobj *remotekey;
 138         des_block *deskey;
 139 {
 140         cryptkeyarg2 arg;
 141         cryptkeyres res;
 142
 143         arg.remotename = remotename;
 144         arg.remotekey = *remotekey;
 145         arg.deskey = *deskey;
 146         if (!key_call((u_long)KEY_ENCRYPT_PK, (xdrproc_t)xdr_cryptkeyarg2, &arg,
 147                         (xdrproc_t)xdr_cryptkeyres, &res)) {
 148                 return (-1);
 149         }
 150         if (res.status != KEY_SUCCESS) {
 151                 debug("encrypt status is nonzero");
 152                 return (-1);
 153         }
 154         *deskey = res.cryptkeyres_u.deskey;
 155         return (0);
 156 }
 157
 158 int
 159 key_decryptsession_pk(remotename, remotekey, deskey)
 160         char *remotename;
 161         netobj *remotekey;
 162         des_block *deskey;
 163 {
 164         cryptkeyarg2 arg;
 165         cryptkeyres res;
 166
 167         arg.remotename = remotename;
 168         arg.remotekey = *remotekey;
 169         arg.deskey = *deskey;
 170         if (!key_call((u_long)KEY_DECRYPT_PK, (xdrproc_t)xdr_cryptkeyarg2, &arg,
 171                         (xdrproc_t)xdr_cryptkeyres, &res)) {
 172                 return (-1);
 173         }
 174         if (res.status != KEY_SUCCESS) {
 175                 debug("decrypt status is nonzero");
 176                 return (-1);
 177         }
 178         *deskey = res.cryptkeyres_u.deskey;
 179         return (0);
 180 }
 181
 182 int
 183 key_encryptsession(remotename, deskey)
 184         const char *remotename;
 185         des_block *deskey;
 186 {
 187         cryptkeyarg arg;
 188         cryptkeyres res;
 189
 190         arg.remotename = (char *) remotename;
 191         arg.deskey = *deskey;
 192         if (!key_call((u_long)KEY_ENCRYPT, (xdrproc_t)xdr_cryptkeyarg, &arg,
 193                         (xdrproc_t)xdr_cryptkeyres, &res)) {
 194                 return (-1);
 195         }
 196         if (res.status != KEY_SUCCESS) {
 197                 debug("encrypt status is nonzero");
 198                 return (-1);
 199         }
 200         *deskey = res.cryptkeyres_u.deskey;
 201         return (0);
 202 }
 203
 204 int
 205 key_decryptsession(remotename, deskey)
 206         const char *remotename;
 207         des_block *deskey;
 208 {
 209         cryptkeyarg arg;
 210         cryptkeyres res;
 211
 212         arg.remotename = (char *) remotename;
 213         arg.deskey = *deskey;
 214         if (!key_call((u_long)KEY_DECRYPT, (xdrproc_t)xdr_cryptkeyarg, &arg,
 215                         (xdrproc_t)xdr_cryptkeyres, &res)) {
 216                 return (-1);
 217         }
 218         if (res.status != KEY_SUCCESS) {
 219                 debug("decrypt status is nonzero");
 220                 return (-1);
 221         }
 222         *deskey = res.cryptkeyres_u.deskey;
 223         return (0);
 224 }
 225
 226 int
 227 key_gendes(key)
 228         des_block *key;
 229 {
 230         if (!key_call((u_long)KEY_GEN, (xdrproc_t)xdr_void, NULL,
 231                         (xdrproc_t)xdr_des_block, key)) {
 232                 return (-1);
 233         }
 234         return (0);
 235 }
 236
 237 int
 238 key_setnet(arg)
 239 struct key_netstarg *arg;
 240 {
 241         keystatus status;
 242
 243
 244         if (!key_call((u_long) KEY_NET_PUT, (xdrproc_t)xdr_key_netstarg, arg,
 245                         (xdrproc_t)xdr_keystatus, &status)){
 246                 return (-1);
 247         }
 248
 249         if (status != KEY_SUCCESS) {
 250                 debug("key_setnet status is nonzero");
 251                 return (-1);
 252         }
 253         return (1);
 254 }
 255
 256
 257 int
 258 key_get_conv(pkey, deskey)
 259         char *pkey;
 260         des_block *deskey;
 261 {
 262         cryptkeyres res;
 263
 264         if (!key_call((u_long) KEY_GET_CONV, (xdrproc_t)xdr_keybuf, pkey,
 265                         (xdrproc_t)xdr_cryptkeyres, &res)) {
 266                 return (-1);
 267         }
 268         if (res.status != KEY_SUCCESS) {
 269                 debug("get_conv status is nonzero");
 270                 return (-1);
 271         }
 272         *deskey = res.cryptkeyres_u.deskey;
 273         return (0);
 274 }
 275
 276 struct  key_call_private {
 277         CLIENT  *client;        /* Client handle */
 278         pid_t   pid;            /* process-id at moment of creation */
 279         uid_t   uid;            /* user-id at last authorization */
 280 };
 281 static struct key_call_private *key_call_private_main = NULL;
 282 static thread_key_t key_call_key;
 283 static once_t key_call_once = ONCE_INITIALIZER;
 284 static int key_call_key_error;
 285
 286 static void
 287 key_call_destroy(void *vp)
 288 {
 289         struct key_call_private *kcp = (struct key_call_private *)vp;
 290
 291         if (kcp) {
 292                 if (kcp->client)
 293                         clnt_destroy(kcp->client);
 294                 free(kcp);
 295         }
 296 }
 297
 298 static void
 299 key_call_init(void)
 300 {
 301
 302         key_call_key_error = thr_keycreate(&key_call_key, key_call_destroy);
 303 }
 304
 305 /*
 306  * Keep the handle cached.  This call may be made quite often.
 307  */
 308 static CLIENT *
 309 getkeyserv_handle(vers)
 310 int     vers;
 311 {
 312         void *localhandle;
 313         struct netconfig *nconf;
 314         struct netconfig *tpconf;
 315         struct key_call_private *kcp;
 316         struct timeval wait_time;
 317         struct utsname u;
 318         int main_thread;
 319         int fd;
 320
 321 #define TOTAL_TIMEOUT   30      /* total timeout talking to keyserver */
 322 #define TOTAL_TRIES     5       /* Number of tries */
 323
 324         if ((main_thread = thr_main())) {
 325                 kcp = key_call_private_main;
 326         } else {
 327                 if (thr_once(&key_call_once, key_call_init) != 0 ||
 328                     key_call_key_error != 0)
 329                         return ((CLIENT *) NULL);
 330                 kcp = (struct key_call_private *)thr_getspecific(key_call_key);
 331         }
 332         if (kcp == (struct key_call_private *)NULL) {
 333                 kcp = (struct key_call_private *)malloc(sizeof (*kcp));
 334                 if (kcp == (struct key_call_private *)NULL) {
 335                         return ((CLIENT *) NULL);
 336                 }
 337                 if (main_thread)
 338                         key_call_private_main = kcp;
 339                 else
 340                         thr_setspecific(key_call_key, (void *) kcp);
 341                 kcp->client = NULL;
 342         }
 343
 344         /* if pid has changed, destroy client and rebuild */
 345         if (kcp->client != NULL && kcp->pid != getpid()) {
 346                 clnt_destroy(kcp->client);
 347                 kcp->client = NULL;
 348         }
 349
 350         if (kcp->client != NULL) {
 351                 /* if uid has changed, build client handle again */
 352                 if (kcp->uid != geteuid()) {
 353                         kcp->uid = geteuid();
 354                         auth_destroy(kcp->client->cl_auth);
 355                         kcp->client->cl_auth =
 356                                 authsys_create("", kcp->uid, 0, 0, NULL);
 357                         if (kcp->client->cl_auth == NULL) {
 358                                 clnt_destroy(kcp->client);
 359                                 kcp->client = NULL;
 360                                 return ((CLIENT *) NULL);
 361                         }
 362                 }
 363                 /* Change the version number to the new one */
 364                 clnt_control(kcp->client, CLSET_VERS, (void *)&vers);
 365                 return (kcp->client);
 366         }
 367         if (!(localhandle = setnetconfig())) {
 368                 return ((CLIENT *) NULL);
 369         }
 370         tpconf = NULL;
 371 #if defined(__FreeBSD__)
 372         if (uname(&u) == -1)
 373 #else
 374 #if defined(i386)
 375         if (_nuname(&u) == -1)
 376 #elif defined(sparc)
 377         if (_uname(&u) == -1)
 378 #else
 379 #error Unknown architecture!
 380 #endif
 381 #endif
 382         {
 383                 endnetconfig(localhandle);
 384                 return ((CLIENT *) NULL);
 385         }
 386         while ((nconf = getnetconfig(localhandle)) != NULL) {
 387                 if (strcmp(nconf->nc_protofmly, NC_LOOPBACK) == 0) {
 388                         /*
 389                          * We use COTS_ORD here so that the caller can
 390                          * find out immediately if the server is dead.
 391                          */
 392                         if (nconf->nc_semantics == NC_TPI_COTS_ORD) {
 393                                 kcp->client = clnt_tp_create(u.nodename,
 394                                         KEY_PROG, vers, nconf);
 395                                 if (kcp->client)
 396                                         break;
 397                         } else {
 398                                 tpconf = nconf;
 399                         }
 400                 }
 401         }
 402         if ((kcp->client == (CLIENT *) NULL) && (tpconf))
 403                 /* Now, try the CLTS or COTS loopback transport */
 404                 kcp->client = clnt_tp_create(u.nodename,
 405                         KEY_PROG, vers, tpconf);
 406         endnetconfig(localhandle);
 407
 408         if (kcp->client == (CLIENT *) NULL) {
 409                 return ((CLIENT *) NULL);
 410         }
 411         kcp->uid = geteuid();
 412         kcp->pid = getpid();
 413         kcp->client->cl_auth = authsys_create("", kcp->uid, 0, 0, NULL);
 414         if (kcp->client->cl_auth == NULL) {
 415                 clnt_destroy(kcp->client);
 416                 kcp->client = NULL;
 417                 return ((CLIENT *) NULL);
 418         }
 419
 420         wait_time.tv_sec = TOTAL_TIMEOUT/TOTAL_TRIES;
 421         wait_time.tv_usec = 0;
 422         (void) clnt_control(kcp->client, CLSET_RETRY_TIMEOUT,
 423                 (char *)&wait_time);
 424         if (clnt_control(kcp->client, CLGET_FD, (char *)&fd))
 425                 _fcntl(fd, F_SETFD, 1); /* make it "close on exec" */
 426
 427         return (kcp->client);
 428 }
 429
 430 /* returns  0 on failure, 1 on success */
 431
 432 static int
 433 key_call(proc, xdr_arg, arg, xdr_rslt, rslt)
 434         u_long proc;
 435         xdrproc_t xdr_arg;
 436         void *arg;
 437         xdrproc_t xdr_rslt;
 438         void *rslt;
 439 {
 440         CLIENT *clnt;
 441         struct timeval wait_time;
 442
 443         if (proc == KEY_ENCRYPT_PK && __key_encryptsession_pk_LOCAL) {
 444                 cryptkeyres *res;
 445                 res = (*__key_encryptsession_pk_LOCAL)(geteuid(), arg);
 446                 *(cryptkeyres*)rslt = *res;
 447                 return (1);
 448         } else if (proc == KEY_DECRYPT_PK && __key_decryptsession_pk_LOCAL) {
 449                 cryptkeyres *res;
 450                 res = (*__key_decryptsession_pk_LOCAL)(geteuid(), arg);
 451                 *(cryptkeyres*)rslt = *res;
 452                 return (1);
 453         } else if (proc == KEY_GEN && __key_gendes_LOCAL) {
 454                 des_block *res;
 455                 res = (*__key_gendes_LOCAL)(geteuid(), 0);
 456                 *(des_block*)rslt = *res;
 457                 return (1);
 458         }
 459
 460         if ((proc == KEY_ENCRYPT_PK) || (proc == KEY_DECRYPT_PK) ||
 461             (proc == KEY_NET_GET) || (proc == KEY_NET_PUT) ||
 462             (proc == KEY_GET_CONV))
 463                 clnt = getkeyserv_handle(2); /* talk to version 2 */
 464         else
 465                 clnt = getkeyserv_handle(1); /* talk to version 1 */
 466
 467         if (clnt == NULL) {
 468                 return (0);
 469         }
 470
 471         wait_time.tv_sec = TOTAL_TIMEOUT;
 472         wait_time.tv_usec = 0;
 473
 474         if (clnt_call(clnt, proc, xdr_arg, arg, xdr_rslt, rslt,
 475                 wait_time) == RPC_SUCCESS) {
 476                 return (1);
 477         } else {
 478                 return (0);
 479         }
 480 }