Home | History | Annotate | Download | only in authtok_check
      1 /*
      2  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
      3  * Use is subject to license terms.
      4  */
      5 
      6 /*
      7  * This program is copyright Alec Muffett 1993. The author disclaims all
      8  * responsibility or liability with respect to it's usage or its effect
      9  * upon hardware or computer systems, and maintains copyright as set out
     10  * in the "LICENCE" document which accompanies distributions of Crack v4.0
     11  * and upwards.
     12  */
     13 
     14 #include "packer.h"
     15 
     16 void
     17 PWRemove(char *path)
     18 {
     19 	char fname[PATH_MAX];
     20 
     21 	(void) snprintf(fname, sizeof (fname), "%s/%s", path,
     22 	    DICT_DATABASE_PWI);
     23 	(void) unlink(fname);
     24 	(void) snprintf(fname, sizeof (fname), "%s/%s", path,
     25 	    DICT_DATABASE_PWD);
     26 	(void) unlink(fname);
     27 	(void) snprintf(fname, sizeof (fname), "%s/%s", path,
     28 	    DICT_DATABASE_HWM);
     29 	(void) unlink(fname);
     30 }
     31 
     32 PWDICT *
     33 PWOpen(char *path, char *mode)
     34 {
     35 	PWDICT *pdesc;
     36 	char iname[PATH_MAX];
     37 	char dname[PATH_MAX];
     38 	char wname[PATH_MAX];
     39 	int fd_d;
     40 	int fd_i;
     41 	int fd_w;
     42 	FILE *dfp;
     43 	FILE *ifp;
     44 	FILE *wfp;
     45 
     46 	if ((pdesc = calloc(1, sizeof (PWDICT))) == NULL)
     47 		return ((PWDICT *) 0);
     48 
     49 	if (pdesc->header.pih_magic == PIH_MAGIC) {
     50 		return ((PWDICT *) 0);
     51 	}
     52 	(void) memset(pdesc, '\0', sizeof (pdesc));
     53 
     54 	(void) snprintf(iname, sizeof (iname), "%s/%s", path,
     55 	    DICT_DATABASE_PWI);
     56 	(void) snprintf(dname, sizeof (dname), "%s/%s", path,
     57 	    DICT_DATABASE_PWD);
     58 	(void) snprintf(wname, sizeof (wname), "%s/%s", path,
     59 	    DICT_DATABASE_HWM);
     60 
     61 	if ((fd_d = open(dname, O_RDWR|O_CREAT, 0600)) == -1)
     62 		syslog(LOG_ERR, "PWopen: can't open %s: %s", dname,
     63 		    strerror(errno));
     64 	if ((fd_i = open(iname, O_RDWR|O_CREAT, 0600)) == -1)
     65 		syslog(LOG_ERR, "PWopen: can't open %s: %s", iname,
     66 		    strerror(errno));
     67 	if ((fd_w = open(wname, O_RDWR|O_CREAT, 0600)) == -1)
     68 		syslog(LOG_ERR, "PWopen: can't open %s: %s", wname,
     69 		    strerror(errno));
     70 
     71 	if (!(pdesc->dfp = fdopen(fd_d, mode))) {
     72 		return ((PWDICT *) 0);
     73 	}
     74 
     75 	if (!(pdesc->ifp = fdopen(fd_i, mode))) {
     76 		(void) fclose(pdesc->dfp);
     77 		return ((PWDICT *) 0);
     78 	}
     79 
     80 	if (pdesc->wfp = fdopen(fd_w, mode)) {
     81 		pdesc->flags |= PFOR_USEHWMS;
     82 	}
     83 
     84 	ifp = pdesc->ifp;
     85 	dfp = pdesc->dfp;
     86 	wfp = pdesc->wfp;
     87 
     88 	if (mode[0] == 'w') {
     89 		pdesc->flags |= PFOR_WRITE;
     90 		pdesc->header.pih_magic = PIH_MAGIC;
     91 		pdesc->header.pih_blocklen = NUMWORDS;
     92 		pdesc->header.pih_numwords = 0;
     93 
     94 		(void) fwrite((char *)&(pdesc->header), sizeof (pdesc->header),
     95 		    1, ifp);
     96 	} else {
     97 		pdesc->flags &= ~PFOR_WRITE;
     98 
     99 		if (!fread((char *)&(pdesc->header), sizeof (pdesc->header),
    100 		    1, ifp)) {
    101 			pdesc->header.pih_magic = 0;
    102 			(void) fclose(ifp);
    103 			(void) fclose(dfp);
    104 			return ((PWDICT *) 0);
    105 		}
    106 
    107 		if (pdesc->header.pih_magic != PIH_MAGIC) {
    108 			pdesc->header.pih_magic = 0;
    109 			(void) fclose(ifp);
    110 			(void) fclose(dfp);
    111 			return ((PWDICT *) 0);
    112 		}
    113 
    114 		if (pdesc->header.pih_blocklen != NUMWORDS) {
    115 			pdesc->header.pih_magic = 0;
    116 			(void) fclose(ifp);
    117 			(void) fclose(dfp);
    118 			return ((PWDICT *) 0);
    119 		}
    120 
    121 		if (pdesc->flags & PFOR_USEHWMS) {
    122 			if (fread(pdesc->hwms, 1, sizeof (pdesc->hwms), wfp) !=
    123 			    sizeof (pdesc->hwms)) {
    124 				pdesc->flags &= ~PFOR_USEHWMS;
    125 			}
    126 		}
    127 	}
    128 	return (pdesc);
    129 }
    130 
    131 int
    132 PWClose(PWDICT *pwp)
    133 {
    134 	if (pwp->header.pih_magic != PIH_MAGIC) {
    135 		return (-1);
    136 	}
    137 
    138 	if (pwp->flags & PFOR_WRITE) {
    139 		pwp->flags |= PFOR_FLUSH;
    140 		(void) PutPW(pwp, (char *)0);	/* flush last index if necess */
    141 
    142 		if (fseek(pwp->ifp, 0L, 0)) {
    143 			return (-1);
    144 		}
    145 
    146 		if (!fwrite((char *)&pwp->header, sizeof (pwp->header),
    147 		    1, pwp->ifp)) {
    148 			return (-1);
    149 		}
    150 
    151 		if (pwp->flags & PFOR_USEHWMS) {
    152 			int i;
    153 			for (i = 1; i <= 0xff; i++) {
    154 				if (!pwp->hwms[i]) {
    155 					pwp->hwms[i] = pwp->hwms[i-1];
    156 				}
    157 			}
    158 			(void) fwrite(pwp->hwms, 1, sizeof (pwp->hwms),
    159 			    pwp->wfp);
    160 		}
    161 	}
    162 
    163 	(void) fclose(pwp->ifp);
    164 	(void) fclose(pwp->dfp);
    165 	(void) fclose(pwp->wfp);
    166 
    167 	pwp->header.pih_magic = 0;
    168 
    169 	free(pwp);
    170 
    171 	return (0);
    172 }
    173 
    174 int
    175 PutPW(PWDICT *pwp, char *string)
    176 {
    177 	if (!(pwp->flags & PFOR_WRITE)) {
    178 		return (-1);
    179 	}
    180 
    181 	if (string) {
    182 		(void) strncpy(pwp->data[pwp->count], string, MAXWORDLEN);
    183 		pwp->data[pwp->count][MAXWORDLEN - 1] = '\0';
    184 
    185 		pwp->hwms[string[0] & 0xff] = pwp->header.pih_numwords;
    186 
    187 		++(pwp->count);
    188 		++(pwp->header.pih_numwords);
    189 
    190 	} else if (!(pwp->flags & PFOR_FLUSH)) {
    191 		return (-1);
    192 	}
    193 
    194 	if ((pwp->flags & PFOR_FLUSH) || !(pwp->count % NUMWORDS)) {
    195 		int i;
    196 		uint32_t datum;
    197 		register char *ostr;
    198 
    199 		datum = (uint32_t)ftell(pwp->dfp);
    200 
    201 		(void) fwrite((char *)&datum, sizeof (datum), 1, pwp->ifp);
    202 
    203 		(void) fputs(pwp->data[0], pwp->dfp);
    204 		(void) putc(0, pwp->dfp);
    205 
    206 		ostr = pwp->data[0];
    207 
    208 		for (i = 1; i < NUMWORDS; i++) {
    209 			register int j;
    210 			register char *nstr;
    211 
    212 			nstr = pwp->data[i];
    213 
    214 			if (nstr[0]) {
    215 				for (j = 0; ostr[j] && nstr[j] &&
    216 				    (ostr[j] == nstr[j]); j++)
    217 					;
    218 				(void) putc(j & 0xff, pwp->dfp);
    219 				(void) fputs(nstr + j, pwp->dfp);
    220 			}
    221 			(void) putc(0, pwp->dfp);
    222 
    223 			ostr = nstr;
    224 		}
    225 
    226 	(void) memset(pwp->data, '\0', sizeof (pwp->data));
    227 	pwp->count = 0;
    228 	}
    229 	return (0);
    230 }
    231 
    232 char *
    233 GetPW(PWDICT *pwp, uint32_t number)
    234 {
    235 	uint32_t datum;
    236 	register int i;
    237 	register char *ostr;
    238 	register char *nstr;
    239 	register char *bptr;
    240 	char buffer[NUMWORDS * MAXWORDLEN];
    241 	static char data[NUMWORDS][MAXWORDLEN];
    242 	static uint32_t prevblock = 0xffffffff;
    243 	uint32_t thisblock;
    244 
    245 	thisblock = number / NUMWORDS;
    246 
    247 	if (prevblock == thisblock) {
    248 		return (data[number % NUMWORDS]);
    249 	}
    250 
    251 	if (fseek(pwp->ifp, sizeof (struct pi_header) +
    252 	    (thisblock * sizeof (uint32_t)), 0)) {
    253 		return (NULL);
    254 	}
    255 
    256 	if (!fread((char *)&datum, sizeof (datum), 1, pwp->ifp)) {
    257 		return (NULL);
    258 	}
    259 
    260 	if (fseek(pwp->dfp, datum, 0)) {
    261 		return (NULL);
    262 	}
    263 
    264 	if (!fread(buffer, 1, sizeof (buffer), pwp->dfp)) {
    265 		return (NULL);
    266 	}
    267 
    268 	prevblock = thisblock;
    269 
    270 	bptr = buffer;
    271 
    272 	for (ostr = data[0]; *(ostr++) = *(bptr++); /* nothing */)
    273 		;
    274 
    275 	ostr = data[0];
    276 
    277 	for (i = 1; i < NUMWORDS; i++) {
    278 		nstr = data[i];
    279 		(void) strcpy(nstr, ostr);
    280 		ostr = nstr + *(bptr++);
    281 		while (*(ostr++) = *(bptr++))
    282 			;
    283 
    284 		ostr = nstr;
    285 	}
    286 
    287 	return (data[number % NUMWORDS]);
    288 }
    289 
    290 uint32_t
    291 FindPW(PWDICT *pwp, char *string)
    292 {
    293 	int lwm;
    294 	int hwm;
    295 	int idx;
    296 
    297 	if (string == NULL)
    298 		return (PW_WORDS(pwp));
    299 
    300 	if (pwp->flags & PFOR_USEHWMS) {
    301 		idx = string[0] & 0xff;
    302 		lwm = idx ? pwp->hwms[idx - 1] : 0;
    303 		hwm = pwp->hwms[idx];
    304 	} else {
    305 		lwm = 0;
    306 		hwm = PW_WORDS(pwp) - 1;
    307 	}
    308 
    309 	for (;;) {
    310 		int cmp;
    311 		int pivot;
    312 		char *this;
    313 
    314 		pivot = lwm + ((hwm+1)-lwm)/2;
    315 
    316 		if (feof(pwp->ifp) && feof(pwp->dfp) && feof(pwp->wfp))
    317 			break;
    318 
    319 		if ((this = GetPW(pwp, pivot)) == NULL)
    320 			break;
    321 
    322 		cmp = strcmp(string, this);		/* INLINE ? */
    323 
    324 		if (cmp == 0)
    325 			return (pivot);
    326 		else if (cmp < 0)
    327 			hwm = pivot-1;
    328 		else
    329 			lwm = pivot+1;
    330 
    331 		if (lwm > hwm)	/* searched all; not found */
    332 			break;
    333 	}
    334 
    335 	/* not found */
    336 	return (PW_WORDS(pwp));
    337 }
    338