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