home *** CD-ROM | disk | FTP | other *** search
/ Tools en Utilities / CDASS_5.ISO / shell / dos / secdr13d.arj / SDCOMMON.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-21  |  10.8 KB  |  387 lines
  1. /* Secure Drive V1.3d */
  2. /* Code common to CRYPTDSK and LOGIN */
  3.  
  4. #include "secdrv.h"
  5.  
  6. struct tsrdata far *cryptdata;
  7.  
  8. char pass1[MAXPASS];
  9. char pass2[MAXPASS];
  10. char Old13Check[4];
  11.  
  12. int  tsr_not_installed=0;
  13. int  tsr_wrong_version=0;
  14. int  df10=1,ef10=1;
  15. int  incfo=3, outcfo=502;  /*1.3c*/
  16.  
  17.  
  18. char compat_mode='N';
  19.  
  20.  
  21. void setrldb(void far *real_dbios_vect);
  22.  
  23. void set_compat_mode(void)
  24. {
  25.  char *p;
  26.  if ((p=getenv("SD10CMP")) != NULL)
  27.   compat_mode = toupper(p[0]);
  28.  if ( compat_mode == 'Y' || compat_mode == 'X')
  29.   {
  30.    printf("\nVersion 1.0 %s Compatibility is Active\n",
  31.     compat_mode == 'X' ? "eXclusive" : "Normal");
  32.   }
  33.  else compat_mode='N';
  34. }
  35.  
  36.  
  37. void invgets(char *input)
  38. {
  39. unsigned i=0;
  40. char c;
  41. while(i<(MAXPASS-1)) {
  42.     c=getch();
  43.     if(c=='\x0d')
  44.         {
  45.         printf("\n");
  46.         *input='\0';
  47.         return;
  48.         }
  49.     else if(c=='\b')
  50.         {
  51.         if(i>0)
  52.             {
  53.             i--;
  54.             input--;
  55.             printf("\b \b");
  56.             }
  57.         }
  58.     else
  59.         {
  60.         printf("*");
  61.         *input++=c;
  62.         i++;
  63.         }
  64.     }
  65. }
  66.  
  67. void readsec(unsigned drive,unsigned head,unsigned track,
  68.              unsigned sector,unsigned nsects,void *buffer)
  69. {
  70. unsigned i;
  71. char c;
  72. for(;;) {
  73.     for(i=0;i<3;i++)
  74.         if(!rldbios(2,drive,head,track,sector,nsects,buffer)) return;
  75.     printf("\nRead error: drive %02x, head %u, track %u\n",
  76.             drive,head,track);
  77.     printf("Abort, Retry, Ignore? ");
  78.     c=toupper(getch()); printf("%c\n",c);
  79.     if(c=='I') return;
  80.     if(c=='A') exit(1);
  81.     }
  82. }
  83.  
  84. void writesec(unsigned drive,unsigned head,unsigned track,
  85.               unsigned sector,unsigned nsects,void *buffer)
  86. {
  87. unsigned i;
  88. char c;
  89. unsigned r;
  90. for(;;) {
  91.     for(i=0;i<3;i++)
  92.      {
  93.         r=rldbios(3,drive,head,track,sector,nsects,buffer);
  94.         if(!r) return;
  95.      }
  96.     if (r == 03 && drive<0x80)
  97.      {
  98.       printf("\nERROR: Disk %c is Write-Protected!\n",drive+'A');
  99.      }
  100.     else
  101.      printf("\nWrite error: drive %02x, head %u, track %u\n",
  102.             drive,head,track);
  103.     printf("Abort, Retry, Ignore? ");
  104.     c=toupper(getch()); printf("%c\n",c);
  105.     if(c=='I') return;
  106.     if(c=='A') exit(1);
  107.     }
  108. }
  109.  
  110. int getyn(void)
  111. {
  112. char c;
  113. for(;;)
  114.     {
  115.     c=getch();
  116.     if(c=='y'||c=='Y') { printf("Yes\n\n"); return(TRUE); }
  117.     if(c=='n'||c=='N') { printf("No\n\n"); return(FALSE); }
  118.     }
  119. }
  120.  
  121. void getkeydf(unsigned char *key,unsigned char *check,unsigned char *buf)
  122. {
  123. unsigned char temp[16];
  124. MD5_CTX md5buf;
  125. unsigned k;
  126.  
  127. invgets(pass1);
  128. setkeydf(key,check,buf);
  129. }
  130.  
  131. void getkey(unsigned char *key,unsigned char *check,int confirm)
  132. {
  133. unsigned char temp[16];
  134. MD5_CTX md5buf;
  135. unsigned k;
  136.  
  137. if(confirm) printf("\
  138. You need a passphrase to encrypt this disk. Your passphrase should be\n\
  139. fairly long, and should not appear verbatim in any literature or text.\n\
  140. Passphrases are case sensitive - this can be a security feature or it\n\
  141. can be a hazard. If you lose or forget your passphrase, there is no way\n\
  142. to recover the encrypted data!\n");
  143. enterpass:
  144. if(confirm) printf("\nEnter passphrase: ");
  145. invgets(pass1);
  146. if(confirm) {
  147.    int good=TRUE;
  148.    int upper=FALSE;
  149.    int lower=FALSE;
  150.    int other=FALSE;
  151.    unsigned i,j;
  152.    char c;
  153.    printf("\n");
  154.    i=strlen(pass1);
  155.    if(i<8) {
  156.        printf("Your passphrase is only %i characters long.\n",i);
  157.        good=FALSE; }
  158.    for(j=0;j<i;j++) {
  159.        c=pass1[j];
  160.        if(isupper(c)) upper=TRUE;
  161.        else if (islower(c)) lower=TRUE;
  162.        else if (!isspace(c)) other=TRUE; }
  163.    if(upper&&!lower&&!other) {
  164.        printf("Your passphrase is monocase (uppercase only).\n");
  165.        good=FALSE; }
  166.    if(lower&&!upper&&!other) {
  167.        printf("Your passphrase is monocase (lowercase only).\n");
  168.        good=FALSE; }
  169.    if(i>15) good=TRUE;
  170.    if(!good) printf("\nThis passphrase may not be secure.\
  171.  If you want to use it, retype it to\nconfirm. If not, press return to\
  172.  try again.\n\n");
  173.    printf("Re-enter passphrase: ");
  174.    invgets(pass2);
  175.    printf("\n");
  176.    if(strcmp(pass1,pass2)) {
  177.        printf("Passphrases do not match. Try again.\n");
  178.        goto enterpass; }
  179.    }
  180. setkeye(key,check);
  181. }
  182.  
  183. void setkeye (unsigned char *key, unsigned char *check)
  184. {
  185.   ef10=(compat_mode != 'N');
  186.   if (ef10)
  187.    setkey10(key,check);
  188.   else
  189.    setkey13(key,check);
  190. }
  191.  
  192.  
  193. void setkeydf(unsigned char *key,unsigned char *check,unsigned char *buf)
  194. {
  195.  memset(Old13Check,0xff,4);
  196.  setkey10(key,check);
  197.  if(memcmp(check,buf+incfo+4,4) == 0)
  198.   {
  199.    df10=1;
  200.    return;
  201.   }
  202.  if(memcmp(check,buf+outcfo+4,4) == 0)
  203.   {
  204.    df10=1;
  205.    return;
  206.   }
  207.  df10=0;
  208.  if (compat_mode == 'X')
  209.   return;
  210.  setkey13(key,check);
  211. }
  212.  
  213. void setkey10(unsigned char *key,unsigned char *check)
  214.  {
  215.   unsigned char temp[16];
  216.   MD5_CTX md5buf;
  217.  
  218.   MD5Init(&md5buf);
  219.   MD5Update(&md5buf,pass1,strlen(pass1));
  220.   MD5Final(key,&md5buf);
  221.  
  222.   MD5Init(&md5buf);
  223.   MD5Update(&md5buf,key,16);
  224.   MD5Final(temp,&md5buf);
  225.   memcpy(check,temp,4);
  226.  }
  227.  
  228. void setkey13(unsigned char *key,unsigned char *check)
  229.  {
  230.   unsigned char temp[16];
  231.   int k;
  232.   MD5_CTX md5buf;
  233.   MD5_CTX md5sav;
  234.  
  235.   MD5Init(&md5buf);
  236.   MD5Update(&md5buf,pass1,strlen(pass1));
  237.   MD5Final(key,&md5buf);
  238.  
  239.   for(k=0;k<PASS_ITER;k++)
  240.    {
  241.     MD5Init(&md5buf);
  242.     MD5Update(&md5buf,key,16);
  243.     MD5Update(&md5buf,pass1,strlen(pass1));
  244.     MD5Final(key,&md5buf);
  245.    }
  246.  
  247.   MD5Init(&md5buf);
  248.   MD5Update(&md5buf,key,16);
  249.   memcpy((void *)&md5sav,(void *)&md5buf,sizeof(md5buf));
  250.   MD5Update(&md5buf,pass1,strlen(pass1));
  251.   MD5Final(temp,&md5buf);
  252.   memcpy(check,temp,4);               /*1.1/1.3A  Check*/
  253.   memcpy((void *)&md5buf,(void *)&md5sav,sizeof(md5buf));
  254.   MD5Final(temp,&md5buf);             /*1.3 Check*/
  255.   memcpy(Old13Check,temp,4);
  256.  }
  257.  
  258. struct tsrdata far *gettsradr(void)
  259. {
  260. unsigned seg;
  261. unsigned ofs;
  262. struct tsrdata far *ptr;
  263. struct REGPACK rgs;
  264.  
  265. rgs.r_ax=0x0800;
  266. rgs.r_dx=0x00f0;
  267. intr(0x13,&rgs);
  268. if(rgs.r_ax==0x0edcb)
  269.  {
  270.   tsr_wrong_version=1;
  271.   return( (struct tsrdata far *) NULL);
  272.  }
  273. if(rgs.r_ax!=0x0edcc)
  274.  {
  275.   tsr_not_installed=1;
  276.   return( (struct tsrdata far *) NULL);
  277.  }
  278. /* ptr=(long) rgs.r_dx+(long) 0x10000*rgs.r_cx; */
  279. ptr = MK_FP(rgs.r_cx,rgs.r_dx);
  280. if (memcmp(ptr->tsrver,"130D",4) != 0)   /*1.3d*/
  281.  {
  282.   tsr_wrong_version=1;
  283.   return( (struct tsrdata far *) NULL);
  284.  }
  285. setrldb(&ptr->real_dbios_vect);
  286. ptr->incfof =incfo;
  287. ptr->outcfof=outcfo;
  288. return(ptr);
  289. }
  290.  
  291. void readptbl(unsigned char drvltr,unsigned *ptdrive,         /*1.1*/
  292.               unsigned *pthead,unsigned *pttrack)             /*1.1*/
  293. {                                                             /*1.1*/
  294. unsigned char buf[512];                                       /*1.1*/
  295. *ptdrive=255;                                                 /*1.1*/
  296. rdptx(0,0,0,&drvltr,ptdrive,pthead,pttrack,FALSE,buf);        /*1.1*/
  297. if(*ptdrive!=255) return;                                     /*1.1*/
  298. else rdptx(1,0,0,&drvltr,ptdrive,pthead,pttrack,FALSE,buf);   /*1.1*/
  299. if(*ptdrive!=255) return;                                     /*1.1*/
  300. else {                                                        /*1.1*/
  301.     drvltr++;                                                 /*1.1*/
  302.     rdptx(0,0,0,&drvltr,ptdrive,pthead,pttrack,TRUE,buf);     /*1.1*/
  303.      }                                                        /*1.1*/
  304. if(*ptdrive!=255) return;                                     /*1.1*/
  305. else {                                                        /*1.1*/
  306.     drvltr++;                                                 /*1.1*/
  307.     rdptx(1,0,0,&drvltr,ptdrive,pthead,pttrack,TRUE,buf);     /*1.1*/
  308.      }                                                        /*1.1*/
  309. }                                                             /*1.1*/
  310.  
  311. void rdptx(unsigned drive,unsigned head,unsigned track,       /*1.1*/
  312.            unsigned char *letter, unsigned *ptdrive,          /*1.1*/
  313.            unsigned *pthead,unsigned *pttrack,int recurse,    /*1.1*/
  314.            unsigned char *buf)                                /*1.1*/
  315. {                                                             /*1.1*/
  316. unsigned i,pt,ph,pc;                                          /*1.1*/
  317. unsigned char *bufp;                                          /*1.1*/
  318. if(rldbios(2,drive+0x80,head,track,1,1,buf)) return;          /*1.1*/
  319. for(i=0;i<4;i++) {                                            /*1.1*/
  320.     bufp=buf+0x1be+(i*16);                                    /*1.1*/
  321.     pt=bufp[4];                                               /*1.1*/
  322.     ph=bufp[1];                                               /*1.1*/
  323.     pc=bufp[3]+(bufp[2]>>6)*256;                              /*1.1*/
  324.     if((pt==1)||(pt==4)||(pt==6)) {                           /*1.1*/
  325.         if(*letter=='C') {                                    /*1.1*/
  326.             *ptdrive=drive;                                   /*1.1*/
  327.             *pthead=ph;                                       /*1.1*/
  328.             *pttrack=pc;                                      /*1.1*/
  329.             return; }                                         /*1.1*/
  330.         else {                                                /*1.1*/
  331.            (*letter)--;                                       /*1.1*/
  332.            if(!recurse) return; } }                           /*1.1*/
  333.     else if(pt==5) rdptx(drive,ph,pc,letter,ptdrive,          /*1.1*/
  334.                          pthead,pttrack,TRUE,buf); }          /*1.1*/
  335. }                                                             /*1.1*/
  336.  
  337. /*      Compute IDEA encryption subkeys Z */
  338. void en_key_idea(word16 *userkey, word16 *Z)
  339. {
  340.         unsigned i,j;
  341.         word16 *Y=Z;
  342.         /*
  343.          * shifts
  344.          */
  345.         for (j=0; j<8; j++)
  346.                 Z[j] = *userkey++;
  347.  
  348.         for (i=0; j<KEYLEN; j++)
  349.         {       i++;
  350.                 Z[i+7] = Z[i & 7] << 9 | Z[i+1 & 7] >> 7;
  351.                 Z += i & 8;
  352.                 i &= 7;
  353.         }
  354.         for(i=0;i<52;i++)
  355.                 Y[i]^=0x0dae;
  356. }        /* en_key_idea */
  357.  
  358. void calcdiskparams(unsigned char *buf,unsigned *maxtrack,
  359.                     unsigned *maxhead,unsigned *maxsector,
  360.                     unsigned *secsize,unsigned serial[2])
  361. {
  362. unsigned long i,l0,l1,l2,l3;
  363. *maxsector=buf[0x18]+256*buf[0x19];
  364. *maxhead=buf[0x1a]+256*buf[0x1b];
  365. *secsize=buf[0x0b]+256*buf[0x0c];
  366. serial[0]=buf[0x27]+256*buf[0x28];
  367. serial[1]=buf[0x29]+256*buf[0x2a];
  368. l0=(unsigned char)buf[0x20];
  369. l1=(unsigned char)buf[0x21];
  370. l2=(unsigned char)buf[0x22];
  371. l3=(unsigned char)buf[0x23];
  372. i=l0+256*(l1+256*(l2+256*(l3)));
  373. if(i==0) i=(unsigned)buf[0x13]+256*buf[0x14];
  374. *maxtrack=i / *maxsector / *maxhead;
  375. if((i%(*maxsector * *maxhead))==0) (*maxtrack)--;
  376. }
  377.  
  378. void clrbufs(void)
  379.  {
  380.   int k;
  381.   for(k=0;k<MAXPASS;k++)
  382.   {
  383.     pass1[k]='\0';
  384.     pass2[k]='\0';
  385.   }
  386.  }
  387.