regtape/verify.pc

   1 /* $Header$
   2  *
   3  * This program will verify signatures on user records in the database.
   4  */
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <ctype.h>
   9 #include <sys/time.h>
  10 #include <moira.h>
  11 #include <moira_site.h>
  12 #include <des.h>
  13 #include <krb.h>
  14 #include <krb_err.h>
  15 #include <gdss.h>
  16 EXEC SQL INCLUDE sqlca;
  17
  18
  19 char *program;
  20
  21 int main(int argc, char **argv)
  22 {
  23   char buf[BUFSIZ], *usercheck[100], sigbuf[256], *data, *db = "moira";
  24   SigInfo si;
  25   struct save_queue *sq;
  26   int status, i, wait, check, debug, fix;
  27   EXEC SQL BEGIN DECLARE SECTION;
  28   char login[10], mid[32], rawsig[256], who[257];
  29   EXEC SQL VAR rawsig IS STRING(256);
  30   int id, timestamp, sms;
  31   EXEC SQL END DECLARE SECTION;
  32
  33   initialize_sms_error_table();
  34   initialize_krb_error_table();
  35   initialize_gdss_error_table();
  36
  37   program = "sign";
  38   check = debug = fix = 0;
  39
  40   for (i = 1; i < argc; i++)
  41     {
  42       if (!strcmp(argv[i], "-w"))
  43         wait++;
  44       else if (!strcmp(argv[i], "-d"))
  45         debug++;
  46       else if (!strcmp(argv[i], "-D"))
  47         setenv("ING_SET", "set printqry");
  48       else if (!strcmp(argv[i], "-fix"))
  49         fix++;
  50       else if (argv[i][0] == '-')
  51         fprintf(stderr, "Usage: %s [-w] [-D] [-fix]\n", argv[0]);
  52       else usercheck[check++] = argv[i];
  53     }
  54
  55   EXEC SQL CONNECT :db IDENTIFIED BY :db;
  56
  57   if (fix)
  58     {
  59       /* Set the name of our kerberos ticket file */
  60       krb_set_tkt_string("/tmp/tkt_sign");
  61       status = 1;
  62       while (status)
  63         {
  64           printf("Authenticating as moira.extra:\n");
  65           status = krb_get_pw_in_tkt("moira", "extra", "ATHENA.MIT.EDU",
  66                                      "krbtgt", "ATHENA.MIT.EDU",
  67                                      DEFAULT_TKT_LIFE, 0);
  68           if (status != 0)
  69             com_err(program, status + krb_err_base, " in krb_get_pw_in_tkt");
  70         }
  71       com_err(program, 0, "authenticated OK");
  72
  73       sms = 0;
  74       EXEC SQL SELECT string_id INTO :sms FROM strings
  75         WHERE string = 'moira.extra@ATHENA.MIT.EDU';
  76       if (sms == 0)
  77         {
  78           com_err(program, 0, " failed to find string "
  79                   "moira.extra@ATHENA.MIT.EDU in database");
  80           dest_tkt();
  81           exit(1);
  82         }
  83
  84       sq = sq_create();
  85     }
  86
  87   if (check == 0)
  88     {
  89       EXEC SQL DECLARE c CURSOR FOR
  90         SELECT login, clearid, signature, string, sigdate
  91         FROM users, strings
  92         WHERE signature != CHR(0) and sigwho = string_id;
  93       EXEC SQL OPEN c;
  94       while (1)
  95         {
  96           EXEC SQL FETCH c INTO :login, :mid, :rawsig, :who, :timestamp;
  97           if (sqlca.sqlcode)
  98             break;
  99           sprintf(buf, "%s:%s", strtrim(login), strtrim(mid));
 100           si.timestamp = timestamp;
 101           si.SigInfoVersion = 0;
 102           kname_parse(si.pname, si.pinst, si.prealm, strtrim(who));
 103           si.rawsig = (unsigned char *) &rawsig[0];
 104           status = GDSS_Recompose(&si, sigbuf);
 105           if (status)
 106             {
 107               com_err(program, gdss2et(status), "recomposing for user %s",
 108                       login);
 109               continue;
 110             }
 111           si.rawsig = NULL;
 112           status = GDSS_Verify(buf, strlen(buf), sigbuf, &si);
 113           if (status)
 114             com_err(program, gdss2et(status), "verifying user %s", login);
 115           if (fix && status == GDSS_E_BADSIG)
 116             sq_save_data(sq, strsave(buf));
 117           if (wait)
 118             {
 119               printf("Next");
 120               fflush(stdout);
 121               gets(buf);
 122             }
 123         }
 124       if (fix)
 125         {
 126           while (sq_get_data(sq, &data))
 127             {
 128               strncpy(login, data, 8);
 129               if (strchr(login, ':'))
 130                 *strchr(login, ':') = '\0';
 131             again:
 132               com_err(program, 0, "fixing sig for %s", login);
 133               status = GDSS_Sign(data, strlen(data), sigbuf, &si);
 134               if (status)
 135                 {
 136                   com_err(program, gdss2et(status), "signing data");
 137                   continue;
 138                 }
 139               si.rawsig = (unsigned char *)rawsig;
 140               status = GDSS_Verify(data, strlen(data), sigbuf, &si);
 141               if (status)
 142                 {
 143                   com_err(program, gdss2et(status), "verifying data");
 144                   continue;
 145                 }
 146               if (strlen(rawsig) > 68)
 147                 {
 148                   sleep(1);
 149                   goto again;
 150                 }
 151
 152               timestamp = si.timestamp;
 153               EXEC SQL UPDATE users
 154                 SET signature = :rawsig, sigwho = :sms, sigdate = :timestamp
 155                 WHERE login = :login;
 156               if (sqlca.sqlcode)
 157                 {
 158                   com_err(program, 0, "dbms error %d", sqlca.sqlcode);
 159                   dest_tkt();
 160                   exit(1);
 161                 }
 162               EXEC SQL COMMIT WORK;
 163             }
 164         }
 165     }
 166   else
 167     {
 168       for (i = check - 1; i >= 0; i--)
 169         {
 170           strcpy(login, usercheck[i]);
 171           EXEC SQL DECLARE s CURSOR FOR
 172             SELECT clearid, signature, string, sigdate
 173             FROM users, strings
 174             WHERE sigwho = string_id and login = :login;
 175           EXEC SQL OPEN s;
 176           while (1)
 177             {
 178               EXEC SQL FETCH s INTO :mid, :rawsig, :who, :timestamp;
 179               if (sqlca.sqlcode)
 180                 break;
 181               sprintf(buf, "%s:%s", strtrim(login), strtrim(mid));
 182               if (debug)
 183                 printf("Verifying \"%s\"\n", buf);
 184               si.timestamp = timestamp;
 185               si.SigInfoVersion = 0;
 186               kname_parse(si.pname, si.pinst, si.prealm, strtrim(who));
 187               si.rawsig = (unsigned char *) &rawsig[0];
 188               status = GDSS_Recompose(&si, sigbuf);
 189               if (status)
 190                 {
 191                   com_err(program, gdss2et(status), "recomposing for user %s",
 192                           login);
 193                   continue;
 194                 }
 195               si.rawsig = NULL;
 196               status = GDSS_Verify(buf, strlen(buf), sigbuf, &si);
 197               if (fix && status == GDSS_E_BADSIG)
 198                 {
 199                   com_err(program, 0, "fixing signature for %s", login);
 200                 againagain:
 201                   status = GDSS_Sign(buf, strlen(buf), sigbuf);
 202                   if (status)
 203                     {
 204                       com_err(program, gdss2et(status), "signing data");
 205                       continue;
 206                     }
 207                   si.rawsig = (unsigned char *) rawsig;
 208                   status = GDSS_Verify(buf, strlen(buf), sigbuf, &si);
 209                   if (status)
 210                     {
 211                       com_err(program, gdss2et(status), "verifying data");
 212                       continue;
 213                     }
 214                   if (strlen(rawsig) > 68)
 215                     {
 216                       sleep(1);
 217                       goto againagain;
 218                     }
 219
 220                   timestamp = si.timestamp;
 221                   EXEC SQL UPDATE users
 222                     SET signature = :rawsig, sigwho = :sms,
 223                     sigdate = :timestamp
 224                     WHERE login = :login;
 225                   if (sqlca.sqlcode != 0)
 226                     {
 227                       com_err(program, 0, "dbms error %d", sqlca.sqlcode);
 228                       dest_tkt();
 229                       exit(1);
 230                     }
 231                   EXEC SQL COMMIT WORK;
 232                 }
 233               else if (status)
 234                 com_err(program, gdss2et(status), "verifying user %s", login);
 235               else
 236                 {
 237                   com_err(program, 0, "signature verified %s", buf);
 238                   if (debug == 2)
 239                     hex_dump(sigbuf);
 240                 }
 241               if (wait)
 242                 {
 243                   printf("Next");
 244                   fflush(stdout);
 245                   gets(buf);
 246                 }
 247             }
 248         }
 249     }
 250
 251   dest_tkt();
 252   exit(0);
 253 }
 254
 255
 256 hex_dump(unsigned  char *p)
 257 {
 258   printf("Size: %d\n", strlen(p));
 259   while (strlen(p) >= 8)
 260     {
 261       printf("%02x %02x %02x %02x %02x %02x %02x %02x\n",
 262              p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
 263       p += 8;
 264     }
 265   switch (strlen(p))
 266     {
 267     case 7:
 268       printf("%02x %02x %02x %02x %02x %02x %02x\n",
 269              p[0], p[1], p[2], p[3], p[4], p[5], p[6]);
 270       break;
 271     case 6:
 272       printf("%02x %02x %02x %02x %02x %02x\n",
 273              p[0], p[1], p[2], p[3], p[4], p[5]);
 274       break;
 275     case 5:
 276       printf("%02x %02x %02x %02x %02x\n",
 277              p[0], p[1], p[2], p[3], p[4]);
 278       break;
 279     case 4:
 280       printf("%02x %02x %02x %02x\n",
 281              p[0], p[1], p[2], p[3]);
 282       break;
 283     case 3:
 284       printf("%02x %02x %02x\n",
 285              p[0], p[1], p[2]);
 286       break;
 287     case 2:
 288       printf("%02x %02x\n",
 289              p[0], p[1]);
 290       break;
 291     case 1:
 292       printf("%02x\n",
 293              p[0]);
 294       break;
 295     default:
 296       return;
 297     }
 298 }