The Tcpdump Group git mirrors - tcpdump/blob - print-krb.c

   1 /*
   2  * Copyright (c) 1995, 1996, 1997
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  *
  21  * Initial contribution from John Hawkinson (jhawk@mit.edu).
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include <tcpdump-stdinc.h>
  29
  30 #include <stdio.h>
  31
  32 #include "interface.h"
  33 #include "extract.h"
  34
  35 static const char tstr[] = " [|kerberos]";
  36
  37 static const u_char *c_print(register const u_char *, register const u_char *);
  38 static const u_char *krb4_print_hdr(const u_char *);
  39 static void krb4_print(const u_char *);
  40
  41 #define AUTH_MSG_KDC_REQUEST                    1<<1
  42 #define AUTH_MSG_KDC_REPLY                      2<<1
  43 #define AUTH_MSG_APPL_REQUEST                   3<<1
  44 #define AUTH_MSG_APPL_REQUEST_MUTUAL            4<<1
  45 #define AUTH_MSG_ERR_REPLY                      5<<1
  46 #define AUTH_MSG_PRIVATE                        6<<1
  47 #define AUTH_MSG_SAFE                           7<<1
  48 #define AUTH_MSG_APPL_ERR                       8<<1
  49 #define AUTH_MSG_DIE                            63<<1
  50
  51 #define KERB_ERR_OK                             0
  52 #define KERB_ERR_NAME_EXP                       1
  53 #define KERB_ERR_SERVICE_EXP                    2
  54 #define KERB_ERR_AUTH_EXP                       3
  55 #define KERB_ERR_PKT_VER                        4
  56 #define KERB_ERR_NAME_MAST_KEY_VER              5
  57 #define KERB_ERR_SERV_MAST_KEY_VER              6
  58 #define KERB_ERR_BYTE_ORDER                     7
  59 #define KERB_ERR_PRINCIPAL_UNKNOWN              8
  60 #define KERB_ERR_PRINCIPAL_NOT_UNIQUE           9
  61 #define KERB_ERR_NULL_KEY                       10
  62
  63 struct krb {
  64         u_int8_t pvno;          /* Protocol Version */
  65         u_int8_t type;          /* Type+B */
  66 };
  67
  68 static const struct tok type2str[] = {
  69         { AUTH_MSG_KDC_REQUEST,         "KDC_REQUEST" },
  70         { AUTH_MSG_KDC_REPLY,           "KDC_REPLY" },
  71         { AUTH_MSG_APPL_REQUEST,        "APPL_REQUEST" },
  72         { AUTH_MSG_APPL_REQUEST_MUTUAL, "APPL_REQUEST_MUTUAL" },
  73         { AUTH_MSG_ERR_REPLY,           "ERR_REPLY" },
  74         { AUTH_MSG_PRIVATE,             "PRIVATE" },
  75         { AUTH_MSG_SAFE,                "SAFE" },
  76         { AUTH_MSG_APPL_ERR,            "APPL_ERR" },
  77         { AUTH_MSG_DIE,                 "DIE" },
  78         { 0,                            NULL }
  79 };
  80
  81 static const struct tok kerr2str[] = {
  82         { KERB_ERR_OK,                  "OK" },
  83         { KERB_ERR_NAME_EXP,            "NAME_EXP" },
  84         { KERB_ERR_SERVICE_EXP,         "SERVICE_EXP" },
  85         { KERB_ERR_AUTH_EXP,            "AUTH_EXP" },
  86         { KERB_ERR_PKT_VER,             "PKT_VER" },
  87         { KERB_ERR_NAME_MAST_KEY_VER,   "NAME_MAST_KEY_VER" },
  88         { KERB_ERR_SERV_MAST_KEY_VER,   "SERV_MAST_KEY_VER" },
  89         { KERB_ERR_BYTE_ORDER,          "BYTE_ORDER" },
  90         { KERB_ERR_PRINCIPAL_UNKNOWN,   "PRINCIPAL_UNKNOWN" },
  91         { KERB_ERR_PRINCIPAL_NOT_UNIQUE,"PRINCIPAL_NOT_UNIQUE" },
  92         { KERB_ERR_NULL_KEY,            "NULL_KEY"},
  93         { 0,                            NULL}
  94 };
  95
  96 static const u_char *
  97 c_print(register const u_char *s, register const u_char *ep)
  98 {
  99         register u_char c;
 100         register int flag;
 101
 102         flag = 1;
 103         while (s < ep) {
 104                 c = *s++;
 105                 if (c == '\0') {
 106                         flag = 0;
 107                         break;
 108                 }
 109                 if (!ND_ISASCII(c)) {
 110                         c = ND_TOASCII(c);
 111                         putchar('M');
 112                         putchar('-');
 113                 }
 114                 if (!ND_ISPRINT(c)) {
 115                         c ^= 0x40;      /* DEL to ?, others to alpha */
 116                         putchar('^');
 117                 }
 118                 putchar(c);
 119         }
 120         if (flag)
 121                 return NULL;
 122         return (s);
 123 }
 124
 125 static const u_char *
 126 krb4_print_hdr(const u_char *cp)
 127 {
 128         cp += 2;
 129
 130 #define PRINT           if ((cp = c_print(cp, snapend)) == NULL) goto trunc
 131
 132         PRINT;
 133         putchar('.');
 134         PRINT;
 135         putchar('@');
 136         PRINT;
 137         return (cp);
 138
 139 trunc:
 140         fputs(tstr, stdout);
 141         return (NULL);
 142
 143 #undef PRINT
 144 }
 145
 146 static void
 147 krb4_print(const u_char *cp)
 148 {
 149         register const struct krb *kp;
 150         u_char type;
 151         u_short len;
 152
 153 #define PRINT           if ((cp = c_print(cp, snapend)) == NULL) goto trunc
 154 /*  True if struct krb is little endian */
 155 #define IS_LENDIAN(kp)  (((kp)->type & 0x01) != 0)
 156 #define KTOHSP(kp, cp)  (IS_LENDIAN(kp) ? EXTRACT_LE_16BITS(cp) : EXTRACT_16BITS(cp))
 157
 158         kp = (struct krb *)cp;
 159
 160         if ((&kp->type) >= snapend) {
 161                 fputs(tstr, stdout);
 162                 return;
 163         }
 164
 165         type = kp->type & (0xFF << 1);
 166
 167         printf(" %s %s: ",
 168             IS_LENDIAN(kp) ? "le" : "be", tok2str(type2str, NULL, type));
 169
 170         switch (type) {
 171
 172         case AUTH_MSG_KDC_REQUEST:
 173                 if ((cp = krb4_print_hdr(cp)) == NULL)
 174                         return;
 175                 cp += 4;        /* ctime */
 176                 TCHECK(*cp);
 177                 printf(" %dmin ", *cp++ * 5);
 178                 PRINT;
 179                 putchar('.');
 180                 PRINT;
 181                 break;
 182
 183         case AUTH_MSG_APPL_REQUEST:
 184                 cp += 2;
 185                 TCHECK(*cp);
 186                 printf("v%d ", *cp++);
 187                 PRINT;
 188                 TCHECK(*cp);
 189                 printf(" (%d)", *cp++);
 190                 TCHECK(*cp);
 191                 printf(" (%d)", *cp);
 192                 break;
 193
 194         case AUTH_MSG_KDC_REPLY:
 195                 if ((cp = krb4_print_hdr(cp)) == NULL)
 196                         return;
 197                 cp += 10;       /* timestamp + n + exp + kvno */
 198                 TCHECK2(*cp, sizeof(short));
 199                 len = KTOHSP(kp, cp);
 200                 printf(" (%d)", len);
 201                 break;
 202
 203         case AUTH_MSG_ERR_REPLY:
 204                 if ((cp = krb4_print_hdr(cp)) == NULL)
 205                         return;
 206                 cp += 4;          /* timestamp */
 207                 TCHECK2(*cp, sizeof(short));
 208                 printf(" %s ", tok2str(kerr2str, NULL, KTOHSP(kp, cp)));
 209                 cp += 4;
 210                 PRINT;
 211                 break;
 212
 213         default:
 214                 fputs("(unknown)", stdout);
 215                 break;
 216         }
 217
 218         return;
 219 trunc:
 220         fputs(tstr, stdout);
 221 }
 222
 223 void
 224 krb_print(const u_char *dat)
 225 {
 226         register const struct krb *kp;
 227
 228         kp = (struct krb *)dat;
 229
 230         if (dat >= snapend) {
 231                 fputs(tstr, stdout);
 232                 return;
 233         }
 234
 235         switch (kp->pvno) {
 236
 237         case 1:
 238         case 2:
 239         case 3:
 240                 printf(" v%d", kp->pvno);
 241                 break;
 242
 243         case 4:
 244                 printf(" v%d", kp->pvno);
 245                 krb4_print((const u_char *)kp);
 246                 break;
 247
 248         case 106:
 249         case 107:
 250                 fputs(" v5", stdout);
 251                 /* Decode ASN.1 here "someday" */
 252                 break;
 253         }
 254         return;
 255 }