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 }