test/lib/ctm013313ruserpass.i

   1 # 1 "ruserpass.c"
   2
   3
   4
   5
   6
   7
   8 # 9 "ruserpass.c"
   9
  10
  11
  12 # 1 "/usr/include/stdio.h"
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23 extern  struct  _iobuf {
  24         int     _cnt;
  25         char    *_ptr;
  26         char    *_base;
  27         int     _bufsiz;
  28         short   _flag;
  29         char    _file;
  30 } _iob[];
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80 struct _iobuf   *fopen();
  81 struct _iobuf   *fdopen();
  82 struct _iobuf   *freopen();
  83 struct _iobuf   *popen();
  84 long    ftell();
  85 char    *fgets();
  86 char    *gets();
  87
  88 # 12 "ruserpass.c"
  89
  90 # 1 "/usr/include/utmp.h"
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116 struct utmp {
 117         char    ut_line[8];
 118         char    ut_name[15];
 119         char    ut_host[16];
 120         long    ut_time;
 121 };
 122 # 13 "ruserpass.c"
 123
 124 # 1 "/usr/include/ctype.h"
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136 extern  char    _ctype_[];
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153 # 14 "ruserpass.c"
 154
 155 # 1 "/usr/include/sys/types.h"
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180 typedef unsigned char   u_char;
 181 typedef unsigned short  u_short;
 182 typedef unsigned int    u_int;
 183 typedef unsigned long   u_long;
 184 typedef unsigned short  ushort;
 185
 186
 187 typedef struct  _physadr { short r[1]; } *physadr;
 188 typedef struct  label_t {
 189         int     val[8];
 190 } label_t;
 191
 192 typedef struct  _quad { long val[2]; } quad;
 193 typedef long    daddr_t;
 194 typedef char *  caddr_t;
 195 typedef u_short ino_t;
 196 typedef long    swblk_t;
 197 typedef u_int   size_t;
 198 typedef int     ssize_t;
 199 typedef long    time_t;
 200 typedef short   dev_t;
 201 typedef long    off_t;
 202 typedef u_short uid_t;
 203 typedef u_short gid_t;
 204 typedef int     pid_t;
 205 typedef u_short mode_t;
 206
 207
 208
 209
 210
 211
 212
 213
 214 # 1 "/usr/include/sys/select.h"
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254 # 1 "/usr/include/sys/types.h"
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265 # 64 "/usr/include/sys/types.h"
 266
 267 # 40 "/usr/include/sys/select.h"
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279 typedef long    fd_mask;
 280
 281
 282 typedef struct fd_set {
 283         fd_mask fds_bits[1];
 284 } fd_set;
 285
 286
 287
 288
 289
 290
 291
 292 int     select();
 293 int     pselect();
 294
 295
 296
 297 # 59 "/usr/include/sys/types.h"
 298
 299 typedef char    bool_t;
 300 typedef u_int   memaddr;
 301 typedef long    ubadr_t;
 302
 303
 304 # 15 "ruserpass.c"
 305
 306 # 1 "/usr/include/sys/stat.h"
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318 struct  stat
 319 {
 320         dev_t   st_dev;
 321         ino_t   st_ino;
 322         unsigned short st_mode;
 323         short   st_nlink;
 324         uid_t   st_uid;
 325         gid_t   st_gid;
 326         dev_t   st_rdev;
 327         off_t   st_size;
 328         time_t  st_atime;
 329         int     st_spare1;
 330         time_t  st_mtime;
 331         int     st_spare2;
 332         time_t  st_ctime;
 333         int     st_spare3;
 334         long    st_blksize;
 335         long    st_blocks;
 336         u_short st_flags;
 337         u_short st_spare4[3];
 338 };
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402 # 100 "/usr/include/sys/stat.h"
 403
 404
 405
 406 # 16 "ruserpass.c"
 407
 408 # 1 "/usr/include/errno.h"
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418 extern  int     errno;
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525 # 121 "/usr/include/errno.h"
 526
 527 # 17 "ruserpass.c"
 528
 529 # 1 "/usr/include/string.h"
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539 # 1 "/usr/include/sys/types.h"
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550 # 64 "/usr/include/sys/types.h"
 551
 552 # 10 "/usr/include/string.h"
 553
 554 # 13 "/usr/include/string.h"
 555
 556
 557 extern  char    *strcat(), *strncat(), *strcpy(), *strncpy(), *index();
 558 extern  char    *rindex(), *strstr(), *syserrlst();
 559 extern  int     strcmp(), strncmp(), strcasecmp(), strncasecmp(), strlen();
 560 extern  int     memcmp();
 561
 562 extern  char    *memccpy(), *memchr(), *memcpy(), *memset(), *strchr();
 563 extern  char    *strdup(), *strpbrk(), *strrchr(), *strsep(), *strtok();
 564 extern  size_t  strcspn(), strspn();
 565
 566 extern  char    *strerror();
 567 # 18 "ruserpass.c"
 568
 569 # 1 "/usr/include/unistd.h"
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615 # 1 "/usr/include/sys/types.h"
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626 # 64 "/usr/include/sys/types.h"
 627
 628 # 46 "/usr/include/unistd.h"
 629
 630
 631
 632
 633
 634
 635 # 54 "/usr/include/unistd.h"
 636
 637
 638 void     _exit();
 639 int      access();
 640 unsigned int     alarm();
 641 pid_t    fork();
 642 gid_t    getegid();
 643 uid_t    geteuid();
 644 gid_t    getgid();
 645 char    *getlogin();
 646 pid_t    getpgrp();
 647 pid_t    getpid();
 648 pid_t    getppid();
 649 uid_t    getuid();
 650 off_t    lseek();
 651 ssize_t  read();
 652 unsigned int     sleep();
 653 char    *ttyname();
 654 ssize_t  write();
 655
 656 char    *brk();
 657 char    *crypt();
 658 void     endusershell();
 659 long     gethostid();
 660 char    *getpass();
 661 char    *getusershell();
 662 char    *getwd();
 663 char    *mktemp();
 664 void     psignal();
 665 extern  char    *sys_siglist[];
 666 char    *re_comp();
 667 char    *sbrk();
 668 int      sethostid();
 669 void     setusershell();
 670 void     sync();
 671 unsigned int     ualarm();
 672 void     usleep();
 673 pid_t    vfork();
 674
 675 extern  char    *optarg;
 676 extern  int     opterr, optind, optopt;
 677
 678
 679 # 19 "ruserpass.c"
 680
 681 # 1 "/usr/include/stdlib.h"
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729 # 58 "/usr/include/stdlib.h"
 730
 731
 732 # 62 "/usr/include/stdlib.h"
 733
 734
 735
 736
 737
 738
 739
 740 void    abort();
 741 int     abs();
 742 int     atexit();
 743 double  atof();
 744 int     atoi();
 745 long    atol();
 746 void    *calloc();
 747 void    exit();
 748 void    free();
 749 char    *getenv();
 750 void    *malloc();
 751 void    qsort();
 752 int     rand();
 753 void    *realloc();
 754 void    srand();
 755 double  strtod();
 756 long    strtol();
 757 unsigned long strtoul();
 758 int     system();
 759
 760 int     putenv();
 761 int     setenv();
 762
 763 void    *alloca();
 764
 765 int     daemon();
 766 char    *devname();
 767 int     getloadavg();
 768
 769 extern char *optarg;
 770 extern int opterr, optind, optopt;
 771 int     getopt();
 772
 773 extern char *suboptarg;
 774 int     getsubopt();
 775
 776 long    random();
 777 char    *setstate();
 778 void    srandom();
 779 void    unsetenv();
 780
 781
 782 # 20 "ruserpass.c"
 783
 784 char    *renvlook();
 785 struct  utmp *getutmp();
 786 static  struct _iobuf *cfile;
 787
 788 ruserpass(host, aname, apass)
 789         char *host, **aname, **apass;
 790 {
 791
 792         renv(host, aname, apass);
 793         if (*aname == 0 || *apass == 0)
 794                 rnetrc(host, aname, apass);
 795         if (*aname == 0) {
 796                 char *myname = getlogin();
 797                 *aname = (char *)malloc(16);
 798                 printf("Name (%s:%s): ", host, myname);
 799                 fflush((&_iob[1]));
 800                 if (read(2, *aname, 16) <= 0)
 801                         exit(1);
 802                 if ((*aname)[0] == '\n')
 803                         *aname = myname;
 804                 else
 805                         if (index(*aname, '\n'))
 806                                 *index(*aname, '\n') = 0;
 807         }
 808         if (*aname && *apass == 0) {
 809                 printf("Password (%s:%s): ", host, *aname);
 810                 fflush((&_iob[1]));
 811                 *apass = getpass("");
 812         }
 813 }
 814
 815 static
 816 renv(host, aname, apass)
 817         char *host, **aname, **apass;
 818 {
 819         register char *cp;
 820         char *stemp, fgetlogin, *comma;
 821
 822         cp = renvlook(host);
 823         if (cp == 0)
 824                 return;
 825         if (!   ((_ctype_+1)[cp[0]]&(01|02)))
 826                 return;
 827         comma = index(cp, ',');
 828         if (comma == 0)
 829                 return;
 830         if (*aname == 0) {
 831                 *aname = (char *)malloc(comma - cp + 1);
 832                 strncpy(*aname, cp, comma - cp);
 833         } else
 834                 if (strncmp(*aname, cp, comma - cp))
 835                         return;
 836         comma++;
 837         cp = (char *)malloc(strlen(comma)+1);
 838         strcpy(cp, comma);
 839         *apass = (char *)malloc(16);
 840         mkpwclear(cp, host[0], *apass);
 841 }
 842
 843 static
 844 char *
 845 renvlook(host)
 846         char *host;
 847 {
 848         register char *cp, **env;
 849         extern char **environ;
 850
 851         env = environ;
 852         for (env = environ; *env != 0; env++)
 853                 if (!strncmp(*env, "MACH", 4)) {
 854                         cp = index(*env, '=');
 855                         if (cp == 0)
 856                                 continue;
 857                         if (strncmp(*env+4, host, cp-(*env+4)))
 858                                 continue;
 859                         return (cp+1);
 860                 }
 861         return (0);
 862 }
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876 static char tokval[100];
 877
 878 static struct toktab {
 879         char *tokstr;
 880         int tval;
 881 } toktab[]= {
 882         "default",      1,
 883         "login",        2,
 884         "password",     3,
 885         "notify",       4,
 886         "write",        5,
 887         "yes",          6,
 888         "y",            6,
 889         "no",           7,
 890         "n",            7,
 891         "command",      8,
 892         "force",        9,
 893         "machine",      11,
 894         0,              0
 895 };
 896
 897 static
 898 rnetrc(host, aname, apass)
 899         char *host, **aname, **apass;
 900 {
 901         char *hdir, buf[1024];
 902         int t;
 903         struct stat stb;
 904         extern int errno;
 905
 906         hdir = getenv("HOME");
 907         if (hdir == 0)
 908                 hdir = ".";
 909         sprintf(buf, "%s/.netrc", hdir);
 910         cfile = fopen(buf, "r");
 911         if (cfile == 0) {
 912                 if (errno !=    2               )
 913                         perror(buf);
 914                 return;
 915         }
 916 next:
 917         while ((t = token())) switch(t) {
 918
 919         case 1:
 920                 (void) token();
 921                 continue;
 922
 923         case 11:
 924                 if (token() != 10 || strcmp(host, tokval))
 925                         continue;
 926                 while ((t = token()) && t != 11) switch(t) {
 927
 928                 case 2:
 929                         if (token())
 930                                 if (*aname == 0) {
 931                                         *aname = (char *)malloc(strlen(tokval) + 1);
 932                                         strcpy(*aname, tokval);
 933                                 } else {
 934                                         if (strcmp(*aname, tokval))
 935                                                 goto next;
 936                                 }
 937                         break;
 938                 case 3:
 939                         if (fstat(      ((cfile)->_file), &stb) >= 0
 940                             && (stb.st_mode & 077) != 0) {
 941         fprintf((&_iob[2]), "Error - .netrc file not correct mode.\n");
 942         fprintf((&_iob[2]), "Remove password or correct mode.\n");
 943                                 exit(1);
 944                         }
 945                         if (token() && *apass == 0) {
 946                                 *apass = (char *)malloc(strlen(tokval) + 1);
 947                                 strcpy(*apass, tokval);
 948                         }
 949                         break;
 950                 case 8:
 951                 case 4:
 952                 case 5:
 953                 case 9:
 954                         (void) token();
 955                         break;
 956                 default:
 957         fprintf((&_iob[2]), "Unknown .netrc option %s\n", tokval);
 958                         break;
 959                 }
 960                 goto done;
 961         }
 962 done:
 963         fclose(cfile);
 964 }
 965
 966 static
 967 token()
 968 {
 969         char *cp;
 970         int c;
 971         struct toktab *t;
 972
 973         if (            (((cfile)->_flag&020)!=0))
 974                 return (0);
 975         while ((c =             (--(cfile)->_cnt>=0? (int)(*(unsigned char *)(cfile)->_ptr++):_filbuf(cfile))) != (-1) &&
 976             (c == '\n' || c == '\t' || c == ' ' || c == ','))
 977                 continue;
 978         if (c == (-1))
 979                 return (0);
 980         cp = tokval;
 981         if (c == '"') {
 982                 while ((c =             (--(cfile)->_cnt>=0? (int)(*(unsigned char *)(cfile)->_ptr++):_filbuf(cfile))) != (-1) && c != '"') {
 983                         if (c == '\\')
 984                                 c =             (--(cfile)->_cnt>=0? (int)(*(unsigned char *)(cfile)->_ptr++):_filbuf(cfile));
 985                         *cp++ = c;
 986                 }
 987         } else {
 988                 *cp++ = c;
 989                 while ((c =             (--(cfile)->_cnt>=0? (int)(*(unsigned char *)(cfile)->_ptr++):_filbuf(cfile))) != (-1)
 990                     && c != '\n' && c != '\t' && c != ' ' && c != ',') {
 991                         if (c == '\\')
 992                                 c =             (--(cfile)->_cnt>=0? (int)(*(unsigned char *)(cfile)->_ptr++):_filbuf(cfile));
 993                         *cp++ = c;
 994                 }
 995         }
 996         *cp = 0;
 997         if (tokval[0] == 0)
 998                 return (0);
 999         for (t = toktab; t->tokstr; t++)
1000                 if (!strcmp(t->tokstr, tokval))
1001                         return (t->tval);
1002         return (10);
1003 }
1004
1005
1006 char *deblknot(), *deblkclr();
1007 char *nbs8decrypt(), *nbs8encrypt();
1008 static char     E[48];
1009
1010
1011
1012
1013 static char     e[] = {
1014         32, 1, 2, 3, 4, 5,
1015          4, 5, 6, 7, 8, 9,
1016          8, 9,10,11,12,13,
1017         12,13,14,15,16,17,
1018         16,17,18,19,20,21,
1019         20,21,22,23,24,25,
1020         24,25,26,27,28,29,
1021         28,29,30,31,32, 1,
1022 };
1023 static
1024 char *nbsencrypt(str,key,result)
1025   char *result;
1026   char *str, *key; {
1027         static char buf[20],oldbuf[20];
1028         register int j;
1029         result[0] = 0;
1030         strcpy(oldbuf,key);
1031         while(*str){
1032                 for(j=0;j<10;j++)buf[j] = 0;
1033                 for(j=0;j<8 && *str;j++)buf[j] = *str++;
1034                 strcat(result,nbs8encrypt(buf,oldbuf));
1035                 strcat(result,"$");
1036                 strcpy(oldbuf,buf);
1037                 }
1038         return(result);
1039         }
1040 static
1041 char *nbsdecrypt(cpt,key,result)
1042   char *result;
1043   char *cpt,*key; {
1044         char *s;
1045         char c,oldbuf[20];
1046         result[0] = 0;
1047         strcpy(oldbuf,key);
1048         while(*cpt){
1049                 for(s = cpt;*s && *s != '$';s++);
1050                 c = *s;
1051                 *s = 0;
1052                 strcpy(oldbuf,nbs8decrypt(cpt,oldbuf));
1053                 strcat(result,oldbuf);
1054                 if(c == 0)break;
1055                 cpt = s + 1;
1056                 }
1057         return(result);
1058         }
1059
1060 static
1061 char *nbs8encrypt(str,key)
1062 char *str, *key; {
1063         static char keyblk[100], blk[100];
1064         register int i;
1065
1066         enblkclr(keyblk,key);
1067         nbssetkey(keyblk);
1068
1069         for(i=0;i<48;i++) E[i] = e[i];
1070         enblkclr(blk,str);
1071         blkencrypt(blk,0);
1072
1073         return(deblknot(blk));
1074 }
1075
1076 static
1077 char *nbs8decrypt(crp,key)
1078 char *crp, *key; {
1079         static char keyblk[100], blk[100];
1080         register int i;
1081
1082         enblkclr(keyblk,key);
1083         nbssetkey(keyblk);
1084
1085         for(i=0;i<48;i++) E[i] = e[i];
1086         enblknot(blk,crp);
1087         blkencrypt(blk,1);
1088
1089         return(deblkclr(blk));
1090 }
1091
1092 static
1093 enblkclr(blk,str)
1094 char *blk,*str; {
1095         register int i,j;
1096         char c;
1097         for(i=0;i<70;i++)blk[i] = 0;
1098         for(i=0; (c= *str) && i<64; str++){
1099                 for(j=0; j<7; j++, i++)
1100                         blk[i] = (c>>(6-j)) & 01;
1101                 i++;
1102                 }
1103         }
1104
1105 static
1106 char *deblkclr(blk)
1107 char *blk; {
1108         register int i,j;
1109         char c;
1110         static char iobuf[30];
1111         for(i=0; i<10; i++){
1112                 c = 0;
1113                 for(j=0; j<7; j++){
1114                         c <<= 1;
1115                         c |= blk[8*i+j];
1116                         }
1117                 iobuf[i] = c;
1118         }
1119         iobuf[i] = 0;
1120         return(iobuf);
1121         }
1122
1123 static
1124 enblknot(blk,crp)
1125 char *blk;
1126 char *crp; {
1127         register int i,j;
1128         char c;
1129         for(i=0;i<70;i++)blk[i] = 0;
1130         for(i=0; (c= *crp) && i<64; crp++){
1131                 if(c>'Z') c -= 6;
1132                 if(c>'9') c -= 7;
1133                 c -= '.';
1134                 for(j=0; j<6; j++, i++)
1135                         blk[i] = (c>>(5-j)) & 01;
1136                 }
1137         }
1138
1139 static
1140 char *deblknot(blk)
1141 char *blk; {
1142         register int i,j;
1143         char c;
1144         static char iobuf[30];
1145         for(i=0; i<11; i++){
1146                 c = 0;
1147                 for(j=0; j<6; j++){
1148                         c <<= 1;
1149                         c |= blk[6*i+j];
1150                         }
1151                 c += '.';
1152                 if(c > '9')c += 7;
1153                 if(c > 'Z')c += 6;
1154                 iobuf[i] = c;
1155         }
1156         iobuf[i] = 0;
1157         return(iobuf);
1158 }
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170 static  char    IP[] = {
1171         58,50,42,34,26,18,10, 2,
1172         60,52,44,36,28,20,12, 4,
1173         62,54,46,38,30,22,14, 6,
1174         64,56,48,40,32,24,16, 8,
1175         57,49,41,33,25,17, 9, 1,
1176         59,51,43,35,27,19,11, 3,
1177         61,53,45,37,29,21,13, 5,
1178         63,55,47,39,31,23,15, 7,
1179 };
1180
1181
1182
1183
1184 static  char    FP[] = {
1185         40, 8,48,16,56,24,64,32,
1186         39, 7,47,15,55,23,63,31,
1187         38, 6,46,14,54,22,62,30,
1188         37, 5,45,13,53,21,61,29,
1189         36, 4,44,12,52,20,60,28,
1190         35, 3,43,11,51,19,59,27,
1191         34, 2,42,10,50,18,58,26,
1192         33, 1,41, 9,49,17,57,25,
1193 };
1194
1195
1196
1197
1198
1199
1200
1201 static  char    PC1_C[] = {
1202         57,49,41,33,25,17, 9,
1203          1,58,50,42,34,26,18,
1204         10, 2,59,51,43,35,27,
1205         19,11, 3,60,52,44,36,
1206 };
1207
1208 static  char    PC1_D[] = {
1209         63,55,47,39,31,23,15,
1210          7,62,54,46,38,30,22,
1211         14, 6,61,53,45,37,29,
1212         21,13, 5,28,20,12, 4,
1213 };
1214
1215
1216
1217
1218 static  char    shifts[] = {
1219         1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
1220 };
1221
1222
1223
1224
1225
1226 static  char    PC2_C[] = {
1227         14,17,11,24, 1, 5,
1228          3,28,15, 6,21,10,
1229         23,19,12, 4,26, 8,
1230         16, 7,27,20,13, 2,
1231 };
1232
1233 static  char    PC2_D[] = {
1234         41,52,31,37,47,55,
1235         30,40,51,45,33,48,
1236         44,49,39,56,34,53,
1237         46,42,50,36,29,32,
1238 };
1239
1240
1241
1242
1243
1244 static  char    C[28];
1245 static  char    D[28];
1246
1247
1248
1249
1250 static  char    KS[16][48];
1251
1252
1253
1254
1255
1256 static
1257 nbssetkey(key)
1258 char *key;
1259 {
1260         register i, j, k;
1261         int t;
1262
1263
1264
1265
1266
1267
1268
1269         for (i=0; i<28; i++) {
1270                 C[i] = key[PC1_C[i]-1];
1271                 D[i] = key[PC1_D[i]-1];
1272         }
1273
1274
1275
1276
1277
1278         for (i=0; i<16; i++) {
1279
1280
1281
1282                 for (k=0; k<shifts[i]; k++) {
1283                         t = C[0];
1284                         for (j=0; j<28-1; j++)
1285                                 C[j] = C[j+1];
1286                         C[27] = t;
1287                         t = D[0];
1288                         for (j=0; j<28-1; j++)
1289                                 D[j] = D[j+1];
1290                         D[27] = t;
1291                 }
1292
1293
1294
1295                 for (j=0; j<24; j++) {
1296                         KS[i][j] = C[PC2_C[j]-1];
1297                         KS[i][j+24] = D[PC2_D[j]-28-1];
1298                 }
1299         }
1300 }
1301
1302
1303
1304
1305
1306
1307
1308 static  char    S[8][64] = {
1309         14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
1310          0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
1311          4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
1312         15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
1313
1314         15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
1315          3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
1316          0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
1317         13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
1318
1319         10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
1320         13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
1321         13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
1322          1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
1323
1324          7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
1325         13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
1326         10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
1327          3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
1328
1329          2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
1330         14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
1331          4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
1332         11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
1333
1334         12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
1335         10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
1336          9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
1337          4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
1338
1339          4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
1340         13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
1341          1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
1342          6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
1343
1344         13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
1345          1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
1346          7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
1347          2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
1348 };
1349
1350
1351
1352
1353
1354 static  char    P[] = {
1355         16, 7,20,21,
1356         29,12,28,17,
1357          1,15,23,26,
1358          5,18,31,10,
1359          2, 8,24,14,
1360         32,27, 3, 9,
1361         19,13,30, 6,
1362         22,11, 4,25,
1363 };
1364
1365
1366
1367
1368 static  char    L[32], R[32];
1369 static  char    tempL[32];
1370 static  char    f[32];
1371
1372
1373
1374
1375 static  char    preS[48];
1376
1377
1378
1379
1380
1381 static
1382 blkencrypt(block, edflag)
1383 char *block;
1384 {
1385         int i, ii;
1386         register t, j, k;
1387
1388
1389
1390
1391         for (j=0; j<64; j++)
1392                 L[j] = block[IP[j]-1];
1393
1394
1395
1396         for (ii=0; ii<16; ii++) {
1397
1398
1399
1400                 if (edflag)
1401                         i = 15-ii;
1402                 else
1403                         i = ii;
1404
1405
1406
1407
1408                 for (j=0; j<32; j++)
1409                         tempL[j] = R[j];
1410
1411
1412
1413
1414                 for (j=0; j<48; j++)
1415                         preS[j] = R[E[j]-1] ^ KS[i][j];
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427                 for (j=0; j<8; j++) {
1428                         t = 6*j;
1429                         k = S[j][(preS[t+0]<<5)+
1430                                 (preS[t+1]<<3)+
1431                                 (preS[t+2]<<2)+
1432                                 (preS[t+3]<<1)+
1433                                 (preS[t+4]<<0)+
1434                                 (preS[t+5]<<4)];
1435                         t = 4*j;
1436                         f[t+0] = (k>>3)&01;
1437                         f[t+1] = (k>>2)&01;
1438                         f[t+2] = (k>>1)&01;
1439                         f[t+3] = (k>>0)&01;
1440                 }
1441
1442
1443
1444
1445                 for (j=0; j<32; j++)
1446                         R[j] = L[j] ^ f[P[j]-1];
1447
1448
1449
1450
1451                 for (j=0; j<32; j++)
1452                         L[j] = tempL[j];
1453         }
1454
1455
1456
1457         for (j=0; j<32; j++) {
1458                 t = L[j];
1459                 L[j] = R[j];
1460                 R[j] = t;
1461         }
1462
1463
1464
1465
1466         for (j=0; j<64; j++)
1467                 block[j] = L[FP[j]-1];
1468 }
1469
1470
1471
1472
1473
1474
1475
1476 static
1477 struct utmp *getutmp(sttyname)
1478 char *sttyname;
1479 {
1480         static struct utmp utmpstr;
1481         struct _iobuf *fdutmp;
1482
1483         if(sttyname == 0 || sttyname[0] == 0)return(0);
1484
1485         fdutmp = fopen("/var/run/utmp","r");
1486         if(fdutmp == 0)return(0);
1487
1488         while(fread(&utmpstr,1,sizeof utmpstr,fdutmp) == sizeof utmpstr)
1489                 if(strcmp(utmpstr.ut_line,sttyname+5) == 0){
1490                         fclose(fdutmp);
1491                         return(&utmpstr);
1492                 }
1493         fclose(fdutmp);
1494         return(0);
1495 }
1496
1497 static
1498 sreverse(sto, sfrom)
1499         register char *sto, *sfrom;
1500 {
1501         register int i;
1502
1503         i = strlen(sfrom);
1504         while (i >= 0)
1505                 *sto++ = sfrom[i--];
1506 }
1507
1508 static
1509 char *mkenvkey(mch)
1510         char mch;
1511 {
1512         static char skey[40];
1513         register struct utmp *putmp;
1514         char stemp[40], stemp1[40], sttyname[30];
1515         register char *sk,*p;
1516
1517         if (isatty(2))
1518                 strcpy(sttyname,ttyname(2));
1519         else if (isatty(0))
1520                 strcpy(sttyname,ttyname(0));
1521         else if (isatty(1))
1522                 strcpy(sttyname,ttyname(1));
1523         else
1524                 return (0);
1525         putmp = getutmp(sttyname);
1526         if (putmp == 0)
1527                 return (0);
1528         sk = skey;
1529         p = putmp->ut_line;
1530         while (*p)
1531                 *sk++ = *p++;
1532         *sk++ = mch;
1533         sprintf(stemp, "%ld", putmp->ut_time);
1534         sreverse(stemp1, stemp);
1535         p = stemp1;
1536         while (*p)
1537                 *sk++ = *p++;
1538         *sk = 0;
1539         return (skey);
1540 }
1541
1542 mkpwunclear(spasswd,mch,sencpasswd)
1543         char mch, *spasswd, *sencpasswd;
1544 {
1545         register char *skey;
1546
1547         if (spasswd[0] == 0) {
1548                 sencpasswd[0] = 0;
1549                 return;
1550         }
1551         skey = mkenvkey(mch);
1552         if (skey == 0) {
1553                 fprintf((&_iob[2]), "Can't make key\n");
1554                 exit(1);
1555         }
1556         nbsencrypt(spasswd, skey, sencpasswd);
1557 }
1558
1559 mkpwclear(sencpasswd,mch,spasswd)
1560         char mch, *spasswd, *sencpasswd;
1561 {
1562         register char *skey;
1563
1564         if (sencpasswd[0] == 0) {
1565                 spasswd[0] = 0;
1566                 return;
1567         }
1568         skey = mkenvkey(mch);
1569         if (skey == 0) {
1570                 fprintf((&_iob[2]), "Can't make key\n");
1571                 exit(1);
1572         }
1573         nbsdecrypt(sencpasswd, skey, spasswd);
1574 }