cde/programs/dtlogin/xdmauth.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $TOG: xdmauth.c /main/4 1997/03/14 13:45:35 barstow $ */
  24 /* (c) Copyright 1997 The Open Group */
  25 /*                                                                      *
  26  * (c) Copyright 1993, 1994 Hewlett-Packard Company                     *
  27  * (c) Copyright 1993, 1994 International Business Machines Corp.       *
  28  * (c) Copyright 1993, 1994 Sun Microsystems, Inc.                      *
  29  * (c) Copyright 1993, 1994 Novell, Inc.                                *
  30  */
  31
  32 /*
  33  * @DEC_COPYRIGHT@
  34  */
  35 /*
  36  * HISTORY
  37  * $Log$
  38  * Revision 1.1.2.3  1995/06/06  20:25:50  Chris_Beute
  39  *      Code snapshot merge from March 15 and SIA changes
  40  *      [1995/05/31  20:17:31  Chris_Beute]
  41  *
  42  * Revision 1.1.2.2  1995/04/21  13:05:43  Peter_Derr
  43  *      dtlogin auth key fixes from deltacde
  44  *      [1995/04/12  19:21:36  Peter_Derr]
  45  *
  46  *      xdm R6 version used to handle XDM-AUTHORIZATION-1
  47  *      [1995/04/12  18:06:02  Peter_Derr]
  48  *
  49  * $EndLog$
  50  */
  51 /*
  52
  53 Copyright (c) 1988  X Consortium
  54
  55 Permission is hereby granted, free of charge, to any person obtaining
  56 a copy of this software and associated documentation files (the
  57 "Software"), to deal in the Software without restriction, including
  58 without limitation the rights to use, copy, modify, merge, publish,
  59 distribute, sublicense, and/or sell copies of the Software, and to
  60 permit persons to whom the Software is furnished to do so, subject to
  61 the following conditions:
  62
  63 The above copyright notice and this permission notice shall be included
  64 in all copies or substantial portions of the Software.
  65
  66 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  67 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  68 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  69 IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR
  70 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  71 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  72 OTHER DEALINGS IN THE SOFTWARE.
  73
  74 Except as contained in this notice, the name of the X Consortium shall
  75 not be used in advertising or otherwise to promote the sale, use or
  76 other dealings in this Software without prior written authorization
  77 from the X Consortium.
  78
  79 */
  80
  81 /*
  82  * xdm - display manager daemon
  83  * Author:  Keith Packard, MIT X Consortium
  84  *
  85  * xdmauth
  86  *
  87  * generate authorization data for XDM-AUTHORIZATION-1 as per XDMCP spec
  88  */
  89
  90 #include "dm.h"
  91
  92 #ifdef HASXDMAUTH
  93
  94 static char     auth_name[256];
  95 static int      auth_name_len;
  96
  97 void
  98 XdmPrintDataHex(const char *s, const char *a, int l)
  99 {
 100     int i;
 101
 102     Debug ("%s", s);
 103     for (i = 0; i < l; i++)
 104         Debug (" %02x", a[i] & 0xff);
 105     Debug ("\n");
 106 }
 107
 108 #ifdef XDMCP
 109 void
 110 XdmPrintArray8Hex(const char *s, ARRAY8Ptr a)
 111 {
 112     XdmPrintDataHex (s, (char *) a->data, a->length);
 113 }
 114 #endif
 115
 116 #if NeedWidePrototypes
 117 void
 118 XdmInitAuth (unsigned int name_len, char *name)
 119 #else
 120 void
 121 XdmInitAuth (unsigned short name_len, char *name)
 122 #endif /* NeedWidePrototypes */
 123 {
 124     if (name_len > 256)
 125         name_len = 256;
 126     auth_name_len = name_len;
 127     memmove( auth_name, name, name_len);
 128 }
 129
 130 /*
 131  * Generate authorization for XDM-AUTHORIZATION-1
 132  *
 133  * When being used with XDMCP, 8 bytes are generated for the session key
 134  * (sigma), as the random number (rho) is already shared between xdm and
 135  * the server.  Otherwise, we'll prepend a random number to pass in the file
 136  * between xdm and the server (16 bytes total)
 137  */
 138
 139 Xauth *
 140 XdmGetAuthHelper (unsigned short namelen, char *name, int includeRho)
 141 {
 142     Xauth   *new;
 143     new = (Xauth *) malloc (sizeof (Xauth));
 144
 145     if (!new)
 146         return (Xauth *) 0;
 147     new->family = FamilyWild;
 148     new->address_length = 0;
 149     new->address = 0;
 150     new->number_length = 0;
 151     new->number = 0;
 152     if (includeRho)
 153         new->data_length = 16;
 154     else
 155         new->data_length = 8;
 156
 157     new->data = (char *) malloc (new->data_length);
 158     if (!new->data)
 159     {
 160         free ((char *) new);
 161         return (Xauth *) 0;
 162     }
 163     new->name = (char *) malloc (namelen);
 164     if (!new->name)
 165     {
 166         free ((char *) new->data);
 167         free ((char *) new);
 168         return (Xauth *) 0;
 169     }
 170     memmove( (char *)new->name, name, namelen);
 171     new->name_length = namelen;
 172     GenerateAuthData ((char *)new->data, new->data_length);
 173     /*
 174      * set the first byte of the session key to zero as it
 175      * is a DES key and only uses 56 bits
 176      */
 177     ((char *)new->data)[new->data_length - 8] = '\0';
 178     XdmPrintDataHex ("Local server auth", (char *)new->data, new->data_length);
 179     return new;
 180 }
 181
 182 #if NeedWidePrototypes
 183 Xauth *
 184 XdmGetAuth (unsigned int namelen, char *name)
 185 #else
 186 Xauth *
 187 XdmGetAuth (unsigned short namelen, char *name)
 188 #endif /* NeedWidePrototypes */
 189 {
 190     return XdmGetAuthHelper (namelen, name, TRUE);
 191 }
 192
 193 #ifdef XDMCP
 194
 195 #if NeedWidePrototypes
 196 void XdmGetXdmcpAuth (struct protoDisplay *pdpy, unsigned int authorizationNameLen, char *authorizationName)
 197 #else
 198 void XdmGetXdmcpAuth (struct protoDisplay *pdpy, unsigned short authorizationNameLen, char *authorizationName)
 199 #endif /* NeedWidePrototypes */
 200 {
 201     Xauth   *fileauth, *xdmcpauth;
 202
 203     if (pdpy->fileAuthorization && pdpy->xdmcpAuthorization)
 204         return;
 205     xdmcpauth = XdmGetAuthHelper (authorizationNameLen, authorizationName, FALSE);
 206     if (!xdmcpauth)
 207         return;
 208     fileauth = (Xauth *) malloc (sizeof (Xauth));
 209     if (!fileauth)
 210     {
 211         XauDisposeAuth(xdmcpauth);
 212         return;
 213     }
 214     /* build the file auth from the XDMCP auth */
 215     *fileauth = *xdmcpauth;
 216     fileauth->name = malloc (xdmcpauth->name_length);
 217     fileauth->data = malloc (16);
 218     fileauth->data_length = 16;
 219     if (!fileauth->name || !fileauth->data)
 220     {
 221         XauDisposeAuth (xdmcpauth);
 222         if (fileauth->name)
 223             free ((char *) fileauth->name);
 224         if (fileauth->data)
 225             free ((char *) fileauth->data);
 226         free ((char *) fileauth);
 227         return;
 228     }
 229     /*
 230      * for the file authorization, prepend the random number (rho)
 231      * which is simply the number we've been passing back and
 232      * forth via XDMCP
 233      */
 234     memmove( fileauth->name, xdmcpauth->name, xdmcpauth->name_length);
 235     memmove( fileauth->data, pdpy->authenticationData.data, 8);
 236     memmove( fileauth->data + 8, xdmcpauth->data, 8);
 237     XdmPrintDataHex ("Accept packet auth", xdmcpauth->data, xdmcpauth->data_length);
 238     XdmPrintDataHex ("Auth file auth", fileauth->data, fileauth->data_length);
 239     /* encrypt the session key for its trip back to the server */
 240     XdmcpWrap (xdmcpauth->data, &pdpy->key, xdmcpauth->data, 8);
 241     pdpy->fileAuthorization = fileauth;
 242     pdpy->xdmcpAuthorization = xdmcpauth;
 243 }
 244
 245 #define atox(c) ('0' <= c && c <= '9' ? c - '0' : \
 246                  'a' <= c && c <= 'f' ? c - 'a' + 10 : \
 247                  'A' <= c && c <= 'F' ? c - 'A' + 10 : -1)
 248
 249 static
 250 HexToBinary (char *key)
 251 {
 252     char    *out, *in;
 253     int     top, bottom;
 254
 255     in = key + 2;
 256     out= key;
 257     while (in[0] && in[1])
 258     {
 259         top = atox(in[0]);
 260         if (top == -1)
 261             return 0;
 262         bottom = atox(in[1]);
 263         if (bottom == -1)
 264             return 0;
 265         *out++ = (top << 4) | bottom;
 266         in += 2;
 267     }
 268     if (in[0])
 269         return 0;
 270     *out++ = '\0';
 271     return 1;
 272 }
 273
 274 /*
 275  * Search the Keys file for the entry matching this display.  This
 276  * routine accepts either plain ascii strings for keys, or hex-encoded numbers
 277  */
 278
 279 XdmGetKey (struct protoDisplay *pdpy, ARRAY8Ptr displayID)
 280 {
 281     FILE    *keys;
 282     char    line[1024], id[1024], key[1024];
 283     int     keylen;
 284
 285     Debug ("Lookup key for %*.*s\n", displayID->length, displayID->length, displayID->data);
 286     keys = fopen (keyFile, "r");
 287     if (!keys)
 288         return FALSE;
 289     while (fgets (line, sizeof (line) -  1, keys))
 290     {
 291         if (line[0] == '#' || sscanf (line, "%s %s", id, key) != 2)
 292             continue;
 293         bzero(line, sizeof(line));
 294         Debug ("Key entry \"%s\" \"%s\"\n", id, key);
 295         if (strlen (id) == displayID->length &&
 296             !strncmp (id, (char *)displayID->data, displayID->length))
 297         {
 298             if (!strncmp (key, "0x", 2) || !strncmp (key, "0X", 2))
 299                 if (!HexToBinary (key))
 300                     break;
 301             keylen = strlen (key);
 302             while (keylen < 7)
 303                 key[keylen++] = '\0';
 304             pdpy->key.data[0] = '\0';
 305             memmove( pdpy->key.data + 1, key, 7);
 306             bzero(key, sizeof(key));
 307             fclose (keys);
 308             return TRUE;
 309         }
 310     }
 311     bzero(line, sizeof(line));
 312     bzero(key, sizeof(key));
 313     fclose (keys);
 314     return FALSE;
 315 }
 316
 317 /*ARGSUSED*/
 318 XdmCheckAuthentication (struct protoDisplay *pdpy, ARRAY8Ptr displayID,
 319                         ARRAY8Ptr authenticationName, ARRAY8Ptr authenticationData)
 320 {
 321     XdmAuthKeyPtr   incoming;
 322
 323     if (!XdmGetKey (pdpy, displayID))
 324         return FALSE;
 325     if (authenticationData->length != 8)
 326         return FALSE;
 327     XdmcpUnwrap (authenticationData->data, &pdpy->key,
 328                   authenticationData->data, 8);
 329     XdmPrintArray8Hex ("Request packet auth", authenticationData);
 330     if (!XdmcpCopyARRAY8(authenticationData, &pdpy->authenticationData))
 331         return FALSE;
 332     incoming = (XdmAuthKeyPtr) authenticationData->data;
 333     XdmcpIncrementKey (incoming);
 334     XdmcpWrap (authenticationData->data, &pdpy->key,
 335                   authenticationData->data, 8);
 336     return TRUE;
 337 }
 338
 339 #endif /* XDMCP */
 340 #endif /* HASXDMAUTH (covering the entire file) */