![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to validate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp / vms|
Return to validate.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / uucp / vms |
1.1 root 1: /*
2: *
3: * Routines to deal with the VMS User Authorization File:
4: *
5: * get_vms_uaf_record(name,uaf);
6: * validate_vms_user(name,password,uaf);
7: * hash_vms_password(output_buf,input_buf,input_len,username,type,salt);
8: *
9: *
10: */
11:
12:
13: /*
14: * Includes
15: */
16: #include <vms/fab.h> /* File access block */
17: #include <vms/rab.h> /* Record access block */
18: #include <vms/rmsdef.h> /* RMS return codes */
19: #include <vms/ssdef.h> /* System service return codes */
20: #include <vms/uafdef.h> /* Authorization file records */
21: #include <vms/logdef.h> /* Logical name table seach masks */
22:
23: /*
24: * defines
25: */
26: #define RETRY_RLK 2 /* number of retries if record locked */
27: #define SLEEP_RLK 75 /* MS to sleep before retrying a GET */
28: #define RECSIZ 80 /* Maximum length for password string */
29: #define UAFNAME "SYSUAF" /* Name of authorization file */
30: #define UAFSIZE 6 /* Size of above */
31: #define DEFNAME "SYS$SYSTEM:.DAT" /* Default path to authorization file */
32: #define DEFSIZE 15 /* Size of above */
33: #define DEFUSER "DEFAULT " /* "Default user" name */
34:
35: #define UAF$_NORMAL 1 /* Normal completion */
36: #define UAF$_INVUSR -2 /* Invalid User Name */
37: #define UAF$_INVPWD -4 /* Invalid Password */
38:
39: #define UAF$S_USERNAME 12 /* User Name Size */
40: #define UAF$S_PWD 8 /* Password Size */
41:
42: struct descr {int size; char *ptr;}; /* VMS descriptor */
43:
44: /*
45: * OWN STORAGE:
46: */
47: static int wakedelta[] = {-10*1000*SLEEP_RLK,-1};
48:
49:
50: /*
51: *
52: * status = get_vms_uaf_record(name,uaf);
53: *
54: */
55: int get_vms_uaf_record(name,uaf)
56: char *name;
57: register struct uaf *uaf;
58: {
59: struct FAB fab;
60: struct RAB rab;
61: unsigned int old_privs[2],new_privs[2];
62: int status;
63: int default_user = 1;
64: register int i;
65: register char *cp,*cp1,*cp2;
66:
67: /*
68: * Zero the fab and rab
69: */
70: bzero(&fab,sizeof(fab));
71: bzero(&rab,sizeof(rab));
72: /*
73: * Setup the fab
74: */
75: fab.fab$b_bid = FAB$C_BID;
76: fab.fab$b_bln = sizeof(fab);
77: fab.fab$l_fna = UAFNAME;
78: fab.fab$b_fns = UAFSIZE;
79: fab.fab$l_dna = DEFNAME;
80: fab.fab$b_dns = DEFSIZE;
81: fab.fab$b_dsbmsk = (1<<LOG$C_GROUP) | (1<<LOG$C_PROCESS);
82: fab.fab$b_fac |= FAB$M_GET;
83: fab.fab$b_shr = (FAB$M_GET|FAB$M_PUT|FAB$M_UPD|FAB$M_DEL);
84: fab.fab$b_org = FAB$C_IDX;
85: fab.fab$b_rfm = FAB$C_VAR;
86: /*
87: * setup the rab
88: */
89: rab.rab$b_bid = RAB$C_BID;
90: rab.rab$b_bln = sizeof(rab);
91: rab.rab$b_rac = RAB$C_KEY;
92: rab.rab$l_rop |= RAB$M_NLK;
93: rab.rab$b_mbc = 10;
94: rab.rab$w_usz = sizeof(struct uaf);
95: rab.rab$l_ubf = (char *)uaf;
96: rab.rab$l_kbfpbf.rab$l_kbf = (unsigned long int *)uaf;
97: rab.rab$b_kszpsz.rab$b_ksz = UAF$S_USERNAME;
98: rab.rab$l_fab = &fab;
99: /*
100: * Enable all privileges that we are authorized to have just to
101: * enhance the possibility of accessing the SYSUAF file.
102: */
103: new_privs[0] = -1; new_privs[1] = -1;
104: sys$setprv(1,new_privs,0,old_privs);
105: /*
106: * Open the File and connect the RAB
107: */
108: status = sys$open(&fab);
109: if (!(status & 1)) {
110: if ((status == RMS$_SNE) ||
111: (status == RMS$_SPE) ||
112: (status == RMS$_DME)) {
113: fab.fab$b_shr = 0;
114: status = sys$open(&fab);
115: if (!(status & 1)) goto exit;
116: } else goto exit;
117: }
118: status = sys$connect(&rab);
119: if (!(status & 1)) goto exit;
120: /*
121: * Move the USERNAME to the uaf$t_username field (as a buffer)
122: * uppercaseify it along the way and check it against the
123: * username "DEFAULT" (which is not a real username). Pad
124: * the uaf$t_username field with blanks.
125: */
126: i = UAF$S_USERNAME;
127: cp = name;
128: cp1 = uaf->uaf$t_username;
129: cp2 = DEFUSER;
130: while(--i >= 0) {
131: if (*cp == 0) break;
132: if (*cp != *cp2++) default_user = 0;
133: *cp1++ = ((*cp >= 'a') && (*cp <= 'z')) ?
134: *cp++ + ('A' - 'a') : *cp++;
135: }
136: i++;
137: while(--i >= 0) {
138: *cp1++ = ' ';
139: if (*cp2++ != ' ') default_user = 0;
140: }
141: /*
142: * The "DEFAULT" user is illegal!
143: */
144: if (default_user) {
145: status = UAF$_INVUSR;
146: goto exit;
147: }
148: /*
149: * Look up the User's UAF record
150: */
151: status = get_record(&rab);
152: if (status == RMS$_RNF) status = UAF$_INVUSR;
153:
154: exit:
155: /*
156: * Done: close the file, release privileges and return status
157: */
158: sys$disconnect(&rab);
159: sys$close(&fab);
160: sys$setprv(0,new_privs,0,0);
161: sys$setprv(1,old_privs,0,0);
162: return(status);
163: }
164:
165:
166: /*
167: * Read the record and deal with file locking
168: */
169: static get_record(rab)
170: struct RAB *rab;
171: {
172: int retries = RETRY_RLK;
173: int status;
174:
175: /*
176: * Re-try the appropriate number of times
177: */
178: while(1) {
179: /*
180: * Get the record
181: */
182: status = sys$get(rab);
183: /*
184: * If the return code is not "Record Locked" it is either
185: * a success or error that we can't handle, return it.
186: */
187: if (status != RMS$_RLK) break;
188: /*
189: * Record Locked: If retries exceeded, return error
190: */
191: if (--retries < 0) break;
192: /*
193: * Retry: Sleep first
194: */
195: status = sys$schdwk(0,0,wakedelta,0);
196: if (status & 1) sys$hiber();
197: }
198: /*
199: * Done: Return status
200: */
201: return(status);
202: }
203:
204:
205: /*
206: *
207: * Validate a UserName/Password pair and return the user's UAF record
208: *
209: */
210: int validate_vms_user(name,password,uaf)
211: char *name;
212: char *password;
213: register struct uaf *uaf;
214: {
215: char password_buf[RECSIZ];
216: char username_buf[UAF$S_USERNAME];
217: char encrypt_buf[UAF$S_PWD];
218: register int i;
219: register char *cp,*cp1;
220:
221: /*
222: * Get the User's UAF record
223: */
224: i = get_vms_uaf_record(name,uaf);
225: if (!(i & 1)) return(i);
226: /*
227: * Limit the username to "UAF$S_USERNAME" size while copying and
228: * uppercasifying it. Pad with spaces to "UAF$S_USERNAME" size.
229: */
230: i = UAF$S_USERNAME;
231: cp = name;
232: cp1 = username_buf;
233: while(--i >= 0) {
234: if (*cp == 0) break;
235: *cp1++ = ((*cp >= 'a') && (*cp <= 'z')) ?
236: *cp++ + ('A' - 'a') : *cp++;
237: }
238: i++;
239: while(--i >= 0) *cp1++ = ' ';
240: /*
241: * Limit the password to "RECSIZ" size while copying and
242: * uppercasifying it.
243: */
244: i = RECSIZ;
245: cp = password;
246: cp1 = password_buf;
247: while(--i >= 0) {
248: if (*cp == 0) break;
249: *cp1++ = ((*cp >= 'a') && (*cp <= 'z')) ?
250: *cp++ + ('A' - 'a') : *cp++;
251: }
252: i = (RECSIZ - 1) - i; /* Compute size of password string */
253: /*
254: * Encrypt the password
255: */
256: hash_vms_password(encrypt_buf,password_buf,i,username_buf,
257: uaf->uaf$b_encrypt,uaf->uaf$w_salt);
258: if (bcmp(encrypt_buf,uaf->uaf$l_pwd,UAF$S_PWD) == 0)
259: return(UAF$_NORMAL);
260: else return(UAF$_INVPWD);
261: }
262:
263:
264: /*
265: *
266: * PASSWORD SMASHING CODE:
267: * The real bit hacking is done in "asm" statements, since
268: * "C" is poorly suited towards quad-word arithmetic!
269: *
270: */
271:
272: /*
273: * AUTODIN II CRC Coefficients:
274: */
275: static unsigned long autodin[] = {
276: 000000000000,003555610144,007333420310,004666230254,
277: 016667040620,015332650764,011554460530,012001270474,
278: 035556101440,036003711504,032665521750,031330331614,
279: 023331141260,020664751324,024002561170,027557371034
280: };
281:
282:
283: /*
284: * PURDY Polynomial Coefficients
285: */
286: static long c[] = {
287: -83, -1, /* C1 */
288: -179, -1, /* C2 */
289: -257, -1, /* C3 */
290: -323, -1, /* C4 */
291: -363, -1 /* C5 */
292: };
293:
294: /*
295: * Hashing routine
296: */
297: hash_vms_password(output_buf,input_buf,input_length,username,type,salt)
298: char *output_buf,*input_buf,*username;
299: unsigned short salt;
300: {
301: register int i;
302: register char *cp;
303:
304: /*
305: * Dispatch on encryption type
306: */
307: if (type == 0) {
308: /*
309: * AUTODIN II CRC:
310: */
311: crc(autodin,-1,input_length,input_buf,output_buf);
312: return;
313: } else {
314: /*
315: * PURDY:
316: */
317:
318: i = 8;
319: cp = output_buf;
320: while(--i >= 0) *cp++ = 0; /* Init output buffer */
321: /*
322: * Collapse the password into a quadword
323: */
324: collapse(input_length,input_buf,output_buf);
325: /*
326: * Add salt to middle of quadword
327: */
328: *((unsigned short *)(output_buf+3)) += salt;
329: /*
330: * Collapse the username into the quadword
331: */
332: collapse(/*UAF$S_USERNAME*/12,username,output_buf);
333: /*
334: * Compute the PURDY polynomial:
335: */
336: purdy(output_buf,c);
337: }
338: }
339:
340: /*
341: * CRC routine:
342: */
343: static crc(table,initial_crc,input_len,input_buf,output_buf)
344: {
345: asm(" crc *4(ap),8(ap),12(ap),*16(ap)");
346: asm(" clrl r1");
347: asm(" movq r0,*20(ap)");
348: }
349:
350: /*
351: * Routine to collapse a string into a quadword:
352: */
353: static collapse(input_len,input_buf,output_buf)
354: register unsigned char *input_buf;
355: register int input_len;
356: register unsigned char *output_buf;
357: {
358: while(input_len > 0) {
359: output_buf[input_len & ~(-8)] += *input_buf++;
360: input_len--;
361: }
362: }
363:
364:
365: /*
366: *
367: * GROMMY STUFF TO COMPUTE THE PURDY POLYNOMIAL
368: *
369: */
370: static purdy(U,C)
371: {
372: /*
373: * This routine computes f(U) = p(U) mod P. Where P is a prime of the form
374: * P = 2^64 - a. The function p is the following polynomial:
375: * X^n0 + X^n1*C1 + X^3*C2 + X^2*C3 + X*C4 + C5
376: * The input U is an unsigned quadword.
377: */
378: asm(" .set A,59"); /* 2^64 -59 is the biggest quad prime */
379:
380: asm(" movq *4(ap),-(sp)"); /* Push U */
381: asm(" bsbw PQMOD_R0"); /* Ensure U less than P */
382: asm(" movaq (sp),r4"); /* Maintain a pointer to X*/
383: asm(" pushl 8(ap)");
384: asm(" movl (sp)+,r5"); /* Point to the table of coefficients */
385: asm(" movq (r4),-(sp)");
386: asm(" pushl $((1<<24)-63)");/* n1 */
387: asm(" bsbb PQEXP_R3"); /* X^n1 */
388: asm(" movq (r4),-(sp)");
389: asm(" pushl $((1<<24)-3)");
390: asm(" subl2 $((1<<24)-63),(sp)");/* n0-n1 */
391: asm(" bsbb PQEXP_R3");
392: asm(" movq (r5)+,-(sp)"); /* C1 */
393: asm(" bsbw PQADD_R0"); /* X^(n0 - n1) + C1 */
394: asm(" bsbw PQMUL_R2"); /* X^n0 + X^n1*C1 */
395: asm(" movq (r5)+,-(sp)"); /* C2 */
396: asm(" movq (r4),-(sp)");
397: asm(" bsbw PQMUL_R2"); /* X*C2 */
398: asm(" movq (r5)+,-(sp)"); /* C3 */
399: asm(" bsbw PQADD_R0"); /* X*C2 + C3 */
400: asm(" movq (r4),-(sp)");
401: asm(" bsbb PQMUL_R2"); /* X^2*C2 + X*C3 */
402: asm(" movq (r5)+,-(sp)"); /* C4 */
403: asm(" bsbw PQADD_R0"); /* X^2*C2 + X*C3 + C4 */
404: asm(" movq (r4),-(sp)");
405: asm(" bsbb PQMUL_R2"); /* X^3*C2 + X^2*C3 + C4*X */
406: asm(" movq (r5)+,-(sp)"); /* C5 */
407: asm(" bsbw PQADD_R0"); /* X^3*C2 + X^2*C3 + C4*X + C5 */
408: asm(" bsbw PQADD_R0"); /* Add in the high order terms */
409: asm(" movq (sp)+,*4(ap)"); /* Replace U with f(X) */
410: asm(" movl $1,r0");
411: asm(" ret");
412:
413:
414: /* Replaces the inputs with U^n mod P where P is of the form */
415: /* P = 2^64 - a. */
416: /* U is a quadword, n is an unsigned longword. */
417:
418: asm("PQEXP_R3:");
419: asm(" popr $8"); /* Record return address */
420: asm(" movq $1,-(sp)"); /* Initialize */
421: asm(" movq 8+4(sp),-(sp)");/* Copy U to top of stack for speed */
422: asm(" tstl 8+8(sp)"); /* Only handle n greater than */
423: asm(" beqlu 3f");
424: asm("1: blbc 8+8(sp),2f");
425: asm(" movq (sp),-(sp)"); /* Copy the current power of U */
426: asm(" movq 8+8(sp),-(sp)");/* Multiply with current value */
427: asm(" bsbb PQMUL_R2");
428: asm(" movq (sp)+,8(sp)"); /* Replace current value */
429: asm(" cmpzv $1,$31,8+8(sp),$0");
430: asm(" beqlu 3f");
431: asm("2: movq (sp),-(sp)"); /* Proceed to next power of U */
432: asm(" bsbb PQMUL_R2");
433: asm(" extzv $1,$31,8+8(sp),8+8(sp)");
434: asm(" brb 1b");
435: asm("3: movq 8(sp),8+8+4(sp)");/* Copy the return value */
436: asm(" movaq 8+8+4(sp),sp"); /* Discard the exponent */
437: asm(" jmp (r3)"); /* return */
438:
439: /* Replaces the quadword U on the stack with U mod P where P is of the */
440: /* form P = 2^64 - a. */
441: asm(" .set U,0"); /* Low longword of U */
442: asm(" .set V,U+4"); /* High longword of U */
443: asm(" .set Y,U+8"); /* Low longword of Y */
444: asm(" .set Z,Y+4"); /* High longword of Y */
445: asm("PQMOD_R0:");
446: asm(" popr $1"); /* Record return address */
447: asm(" cmpl V(sp),$-1"); /* Replace U with U mod P */
448: asm(" blssu 1f");
449: asm(" cmpl U(sp),$-A");
450: asm(" blssu 1f");
451: asm(" addl2 $A,U(sp)");
452: asm(" adwc $0,V(sp)");
453: asm("1: jmp (r0)"); /* return */
454:
455:
456: /* Computes the product U*Y mod P where P is of the form
457: * P = 2^64 - a. U, Y are quadwords less than P. The product
458: * replaces U and Y on the stack.
459: *
460: * The product may be formed as the sum of four longword
461: * multiplications which are scaled by powers of 2^32 by evaluating:
462: * 2^64*v*z + 2^32*(v*y + u*z) + u*y
463: * The result is computed such that division by the modulus P
464: * is avoided.
465: */
466: asm("PQMUL_R2:");
467: asm(" popr $2"); /* Record return address */
468: asm(" movl sp,r2"); /* Record initial stack value */
469: asm(" pushl Z(r2)");
470: asm(" pushl V(r2)");
471: asm(" bsbb EMULQ");
472: asm(" bsbb PQMOD_R0");
473: asm(" bsbb PQLSH_R0"); /* Obtain 2^32*v*z */
474: asm(" pushl Y(r2)");
475: asm(" pushl V(r2)");
476: asm(" bsbb EMULQ");
477: asm(" bsbb PQMOD_R0");
478: asm(" pushl Z(r2)");
479: asm(" pushl U(r2)");
480: asm(" bsbb EMULQ");
481: asm(" bsbb PQMOD_R0");
482: asm(" bsbb PQADD_R0"); /* Obtain (v*y + u*z) */
483: asm(" bsbb PQADD_R0"); /* Add in 2^32*v*z */
484: asm(" bsbb PQLSH_R0"); /* Obtain the first two terms */
485: asm(" pushl Y(r2)");
486: asm(" pushl U(r2)");
487: asm(" bsbb EMULQ");
488: asm(" bsbb PQMOD_R0"); /* Obtain the third term: u*y */
489: asm(" bsbb PQADD_R0"); /* Add it in */
490: asm(" movq (sp)+,Y(r2)"); /* Copy the return value */
491: asm(" movaq Y(r2),sp"); /* Point the stack to the return value */
492: asm(" jmp (r1)"); /* return */
493:
494:
495: /* This routine knows how to multiply two unsigned longwords,
496: * replacing them with the unsigned quadword product on the stack.
497: */
498:
499: asm("EMULQ:");
500: asm(" emul 4(sp),8(sp),$0,-(sp)");
501: asm(" clrl -(sp)");
502: asm(" tstl 4+8+4(sp)"); /* Check both longwords to see if we */
503: asm(" bgeq 1f"); /* must compensate for the unsigned
504: bias. */
505: asm(" addl2 4+8+8(sp),(sp)");
506: asm("1: tstl 4+8+8(sp)");
507: asm(" bgeq 2f");
508: asm(" addl2 4+8+4(sp),(sp)");
509: asm("2: addl2 (sp)+,4(sp)"); /* Add in the compensation. */
510: asm(" movq (sp)+,4(sp)"); /* Replace the longwords with their
511: product. */
512: asm(" rsb");
513:
514: /*
515: * Computes the product 2^32*U mod P where P is of the form
516: * P = 2^64 - a. U is a quadword less than P. The product replaces
517: * U on the stack.
518: *
519: * This routine is used by PQMUL in the formation of quadword
520: * products in such a way as to avoid division by the modulus P.
521: * The product 2^64*v + 2^32*u is congruent a*v + 2^32*u mod P
522: * (where u, v are longwords).
523: */
524: asm("PQLSH_R0:");
525: asm(" popr $1"); /* Record return address */
526: asm(" pushl V(sp)");
527: asm(" pushl $A");
528: asm(" bsbb EMULQ"); /* Push a*v */
529: asm(" ashq $32,Y(sp),Y(sp)");/* Form Y = 2^32*u */
530: asm(" brb PQADD_R0_1"); /* Return the sum U + Y mod P. */
531:
532: /*
533: * Computes the sum U + Y mod P where P is of the form P = 2^64 - a.
534: * U, Y are quadwords less than P. The sum replaces U and Y on
535: * the stack.
536: */
537: asm("PQADD_R0:");
538: asm(" popr $1"); /* Record return address */
539: asm("PQADD_R0_1:");
540: asm(" addl2 U(sp),Y(sp)") /* Add the low longwords */
541: asm(" adwc V(sp),Z(sp)"); /* Add the high longwords with the carry */
542: asm(" bcs 2f"); /* If the result is greater than a quadword */
543: asm(" cmpl Z(sp),$-1");
544: asm(" blssu 3f");
545: asm(" cmpl Y(sp),$-A"); /* or simply greater than or equal to P */
546: asm(" blssu 3f");
547: asm("2: addl2 $A,Y(sp)"); /* we must subtract P.*/
548: asm(" adwc $0,Z(sp)");
549: asm("3: movaq Y(sp),sp"); /* Point the stack to the return value */
550: asm(" jmp (r0)"); /* return */
551: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.