workspace/kdm/backend/xdmauth.c

   1 /*
   2
   3 Copyright 1988, 1998  The Open Group
   4 Copyright 2001,2003 Oswald Buddenhagen <ossi@kde.org>
   5
   6 Permission to use, copy, modify, distribute, and sell this software and its
   7 documentation for any purpose is hereby granted without fee, provided that
   8 the above copyright notice appear in all copies and that both that
   9 copyright notice and this permission notice appear in supporting
  10 documentation.
  11
  12 The above copyright notice and this permission notice shall be included
  13 in all copies or substantial portions of the Software.
  14
  15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  16 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  18 IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19 OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21 OTHER DEALINGS IN THE SOFTWARE.
  22
  23 Except as contained in this notice, the name of a copyright holder shall
  24 not be used in advertising or otherwise to promote the sale, use or
  25 other dealings in this Software without prior written authorization
  26 from the copyright holder.
  27
  28 */
  29
  30 /*
  31  * xdm - display manager daemon
  32  * Author: Keith Packard, MIT X Consortium
  33  *
  34  * generate authorization data for XDM-AUTHORIZATION-1 as per XDMCP spec
  35  */
  36
  37 #include "dm.h"
  38 #include "dm_auth.h"
  39 #include "dm_error.h"
  40
  41 static char authName[256];
  42 static int authNameLen;
  43
  44 void
  45 xdmInitAuth( unsigned short name_len, const char *name )
  46 {
  47         if (name_len > 256)
  48                 name_len = 256;
  49         authNameLen = name_len;
  50         memmove( authName, name, name_len );
  51 }
  52
  53 /*
  54  * Generate authorization for XDM-AUTHORIZATION-1
  55  *
  56  * When being used with XDMCP, 8 bytes are generated for the session key
  57  * (sigma), as the random number (rho) is already shared between xdm and
  58  * the server. Otherwise, we'll prepend a random number to pass in the file
  59  * between xdm and the server (16 bytes total)
  60  */
  61
  62 static Xauth *
  63 xdmGetAuthHelper( unsigned short namelen, const char *name, int includeRho )
  64 {
  65         Xauth *new;
  66
  67         if (!(new = (Xauth *)Malloc( sizeof(Xauth) )))
  68                 return (Xauth *)0;
  69         new->family = FamilyWild;
  70         new->address_length = 0;
  71         new->address = 0;
  72         new->number_length = 0;
  73         new->number = 0;
  74         if (includeRho)
  75                 new->data_length = 16;
  76         else
  77                 new->data_length = 8;
  78
  79         new->data = (char *)Malloc( new->data_length );
  80         if (!new->data) {
  81                 free( (char *)new );
  82                 return (Xauth *)0;
  83         }
  84         new->name = (char *)Malloc( namelen );
  85         if (!new->name) {
  86                 free( (char *)new->data );
  87                 free( (char *)new );
  88                 return (Xauth *)0;
  89         }
  90         memmove( (char *)new->name, name, namelen );
  91         new->name_length = namelen;
  92         if (!generateAuthData( (char *)new->data, new->data_length )) {
  93                 free( (char *)new->name );
  94                 free( (char *)new->data );
  95                 free( (char *)new );
  96                 return (Xauth *)0;
  97         }
  98         /*
  99          * set the first byte of the session key to zero as it
 100          * is a DES key and only uses 56 bits
 101          */
 102         ((char *)new->data)[new->data_length - 8] = '\0';
 103         debug( "local server auth %02[*hhx\n", new->data_length, new->data );
 104         return new;
 105 }
 106
 107 Xauth *
 108 xdmGetAuth( unsigned short namelen, const char *name )
 109 {
 110         return xdmGetAuthHelper( namelen, name, True );
 111 }
 112
 113 #ifdef XDMCP
 114
 115 void
 116 xdmGetXdmcpAuth( struct protoDisplay *pdpy,
 117                  unsigned short authorizationNameLen,
 118                  const char *authorizationName )
 119 {
 120         Xauth *fileauth, *xdmcpauth;
 121
 122         if (pdpy->fileAuthorization && pdpy->xdmcpAuthorization)
 123                 return;
 124         xdmcpauth = xdmGetAuthHelper( authorizationNameLen, authorizationName,
 125                                       False );
 126         if (!xdmcpauth)
 127                 return;
 128         fileauth = (Xauth *)Malloc( sizeof(Xauth) );
 129         if (!fileauth) {
 130                 XauDisposeAuth( xdmcpauth );
 131                 return;
 132         }
 133         /* build the file auth from the XDMCP auth */
 134         *fileauth = *xdmcpauth;
 135         fileauth->name = Malloc( xdmcpauth->name_length );
 136         fileauth->data = Malloc( 16 );
 137         fileauth->data_length = 16;
 138         if (!fileauth->name || !fileauth->data) {
 139                 XauDisposeAuth( xdmcpauth );
 140                 if (fileauth->name)
 141                         free( (char *)fileauth->name );
 142                 if (fileauth->data)
 143                         free( (char *)fileauth->data );
 144                 free( (char *)fileauth );
 145                 return;
 146         }
 147         /*
 148          * for the file authorization, prepend the random number (rho)
 149          * which is simply the number we've been passing back and
 150          * forth via XDMCP
 151          */
 152         memmove( fileauth->name, xdmcpauth->name, xdmcpauth->name_length );
 153         memmove( fileauth->data, pdpy->authenticationData.data, 8 );
 154         memmove( fileauth->data + 8, xdmcpauth->data, 8 );
 155         debug( "accept packet auth %02[*hhx\nauth file auth %02[*hhx\n",
 156                xdmcpauth->data_length, xdmcpauth->data,
 157                fileauth->data_length, fileauth->data );
 158         /* encrypt the session key for its trip back to the server */
 159         XdmcpWrap( (unsigned char *)xdmcpauth->data, (unsigned char *)&pdpy->key,
 160                    (unsigned char *)xdmcpauth->data, 8 );
 161         pdpy->fileAuthorization = fileauth;
 162         pdpy->xdmcpAuthorization = xdmcpauth;
 163 }
 164
 165 #define atox(c) ('0' <= c && c <= '9' ? c - '0' : \
 166                                  'a' <= c && c <= 'f' ? c - 'a' + 10 : \
 167                                  'A' <= c && c <= 'F' ? c - 'A' + 10 : -1)
 168
 169 static int
 170 hexToBinary( char *key )
 171 {
 172         char *out, *in;
 173         int top, bottom;
 174
 175         in = key + 2;
 176         out= key;
 177         while (in[0] && in[1]) {
 178                 top = atox( in[0] );
 179                 if (top == -1)
 180                         return False;
 181                 bottom = atox( in[1] );
 182                 if (bottom == -1)
 183                         return False;
 184                 *out++ = (top << 4) | bottom;
 185                 in += 2;
 186         }
 187         if (in[0])
 188                 return False;
 189         *out++ = '\0';
 190         return True;
 191 }
 192
 193 /*
 194  * Search the Keys file for the entry matching this display.  This
 195  * routine accepts either plain ascii strings for keys, or hex-encoded numbers
 196  */
 197
 198 static int
 199 xdmGetKey( struct protoDisplay *pdpy, ARRAY8Ptr displayID )
 200 {
 201         FILE *keys;
 202         char line[1024], id[1024], key[1024];
 203         int keylen;
 204
 205         debug( "lookup key for %.*s\n", displayID->length, displayID->data );
 206         keys = fopen( keyFile, "r" );
 207         if (!keys)
 208                 return False;
 209         while (fgets( line, sizeof(line), keys )) {
 210                 if (line[0] == '#' || sscanf( line, "%s %s", id, key ) != 2)
 211                         continue;
 212                 bzero( line, sizeof(line) );
 213                 debug( "key entry for %\"s %d bytes\n", id, strlen( key ) );
 214                 if (strlen( id ) == displayID->length &&
 215                     !strncmp( id, (char *)displayID->data, displayID->length ))
 216                 {
 217                         if (!strncmp( key, "0x", 2 ) || !strncmp( key, "0X", 2 ))
 218                                 if (!hexToBinary( key ))
 219                                         break;
 220                         keylen = strlen( key );
 221                         while (keylen < 7)
 222                                 key[keylen++] = '\0';
 223                         pdpy->key.data[0] = '\0';
 224                         memmove( pdpy->key.data + 1, key, 7 );
 225                         bzero( key, sizeof(key) );
 226                         fclose( keys );
 227                         return True;
 228                 }
 229         }
 230         bzero( line, sizeof(line) );
 231         bzero( key, sizeof(key) );
 232         fclose( keys );
 233         return False;
 234 }
 235
 236 /*ARGSUSED*/
 237 int
 238 xdmcheckAuthentication( struct protoDisplay *pdpy,
 239                         ARRAY8Ptr displayID,
 240                         ARRAY8Ptr authenticationName ATTR_UNUSED,
 241                         ARRAY8Ptr authenticationData )
 242 {
 243         XdmAuthKeyPtr incoming;
 244
 245         if (!xdmGetKey( pdpy, displayID ))
 246                 return False;
 247         if (authenticationData->length != 8)
 248                 return False;
 249         XdmcpUnwrap( authenticationData->data, (unsigned char *)&pdpy->key,
 250                      authenticationData->data, 8 );
 251         debug( "request packet auth %02[*hhx\n",
 252                authenticationData->length, authenticationData->data );
 253         if (!XdmcpCopyARRAY8( authenticationData, &pdpy->authenticationData ))
 254                 return False;
 255         incoming = (XdmAuthKeyPtr)authenticationData->data;
 256         XdmcpIncrementKey( incoming );
 257         XdmcpWrap( authenticationData->data, (unsigned char *)&pdpy->key,
 258                    authenticationData->data, 8 );
 259         return True;
 260 }
 261
 262 #endif /* XDMCP */