xref: /illumos-gate/usr/src/cmd/bnu/security.c (revision 55fea89d)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
23 /*	  All Rights Reserved  	*/
24 
25 
26 #ident	"%Z%%M%	%I%	%E% SMI"	/* from SVR4 bnu:security.c 1.3 */
27 /*
28  */
29 
30 #include	"uucp.h"
31 #include	"log.h"
32 
33 extern int guinfo();
34 
35 /*
36  *		SYMBOL DEFINITIONS
37  */
38 
39 #define	FS		' '	/* Field seperator for output records. */
40 #define LOGCHECK	{ if (Collecting == FALSE) return; }
41 #define LOGCHECKC	{ if (Collecting == FALSE) return(NOTAVAIL); }
42 
43 /*
44  *		STRUCTURE DEFINITIONS
45  */
46 
47 struct secXfer			/* Data for construction of security record. */
48 		{
49 			char	reqSystem[MODSTR]; /* requester system name */
50 			char	reqUser[MODSTR]; /* requester login name */
51 			char	desSystem[MODSTR]; /* destination system name */
52 			char	desUser[MODSTR]; /* destination login name */
53 			char	desFile[MODSTR]; /* destination file name */
54 			char	srcSystem[MODSTR]; /* source system name */
55 			char	srcOwner[MODSTR]; /* source file owner */
56 			char	srcFile[MODSTR]; /* source file name */
57 			char	srcSize[MODSTR];/* source file size in Bytes .*/
58 			char	srcMtime[MODSTR]; /* modification date and time of
59 						source file */
60 			char	stime[MODSTR]; /* date and time that transfer
61  							started */
62 			char	etime[MODSTR]; /* date and time that transfer
63  							completed */
64 		};
65 
66 struct secRexe			/* Data for construction of security record. */
67 		{
68 			char	cliSystem[MODSTR]; /* client system name */
69 			char	cliUser[MODSTR]; /* client login name */
70 			char	serUser[MODSTR]; /* server login name */
71 			char	time[MODSTR]; /* date and time that command was
72 						 issued*/
73 			char	command[BUFSIZ]; /* command name and options */
74 		};
75 /*
76  *		LOCAL DATA
77  */
78 
79 static int		Collecting = TRUE; /* ok to collect security inf.*/
80 static int		LogFile = CLOSED; /* Log file file destriptor. */
81 static char		LogName[] = SECURITY; /* Name of our log file. */
82 static char		Record[LOGSIZE]; /* Place to build log records. */
83 static char		Type[MODSTR]; /* record type */
84 
85 static struct secXfer	Xfer;	/* security transfer data. */
86 static struct secRexe	Rexe;	/* security remote execution data. */
87 
88 /*
89  *		LOCAL FUNCTIONS
90  */
91 
92 
93 /*
94  * Local Function:	newRec - Initialize new record
95  */
96 
97 STATIC_FUNC void
newRec(type)98 newRec(type)
99 char * type;
100 {
101 	register struct secXfer *	scptr = &Xfer;
102 	register struct secRexe *	reptr = &Rexe;
103 
104 	if EQUALS(type,"xfer"){
105 	   copyText(scptr->reqUser, sizeof(scptr->reqUser), NOTAVAIL);
106 	   copyText(scptr->desSystem, sizeof(scptr->desSystem), NOTAVAIL);
107 	   copyText(scptr->desUser, sizeof(scptr->desUser), NOTAVAIL);
108 	   copyText(scptr->desFile, sizeof(scptr->desFile), NOTAVAIL);
109 	   copyText(scptr->srcSystem, sizeof(scptr->srcSystem), NOTAVAIL);
110 	   copyText(scptr->srcOwner, sizeof(scptr->srcOwner), NOTAVAIL);
111 	   copyText(scptr->srcFile, sizeof(scptr->srcFile), NOTAVAIL);
112 	   copyText(scptr->srcMtime, sizeof(scptr->srcMtime), NOTAVAIL);
113 	   copyText(scptr->stime, sizeof(scptr->stime), NOTAVAIL);
114 	   copyText(scptr->etime, sizeof(scptr->etime), NOTAVAIL);
115 	}
116 	else {
117 	   copyText(reptr->cliSystem, sizeof(reptr->cliSystem), NOTAVAIL);
118 	   copyText(reptr->cliUser, sizeof(reptr->cliUser), NOTAVAIL);
119 	   copyText(reptr->serUser, sizeof(reptr->serUser), NOTAVAIL);
120 	   copyText(reptr->time, sizeof(reptr->time), NOTAVAIL);
121 	   copyText(reptr->command, sizeof(reptr->command), NOTAVAIL);
122 	}
123 	return;
124 }
125 
126 /*
127  *		EXTERNAL FUNCTIONS
128  */
129 
130 
131 /*
132  * Function:	scInit - Initialize Security Package
133  *
134  * This function allows the security package to initialize its internal
135  * data structures.  It should be called when uucico starts running on master
136  * or slave, or uuxqt is invoked.
137  *
138  * Parameters:
139  *
140  *	type: file transfer or remote exec.
141  */
142 
143 void
scInit(type)144 scInit (type)
145 char * type;
146 
147 {
148 
149 	if (LogFile == CLOSED) {
150 		errno = 0;
151 		LogFile = open(LogName, O_WRONLY | O_APPEND);
152 		if (errno == ENOENT) {
153 			LogFile = creat(LogName, LOGFILEMODE);
154 			(void) chmod(LogName, LOGFILEMODE);
155 		}
156 		if (LogFile < 0){
157 			Collecting = FALSE;
158 			return;
159 		}
160 	}
161 	copyText(Type, sizeof(Type), type);
162 	newRec(Type);
163 	return;
164 }
165 
166 /*
167  * Function:	scWrite - write an entry to the log
168  *			  initialize the next entry
169  */
170 
171 void
scWrite()172 scWrite()
173 
174 {
175 	static char	format[] = "%s%c%s%c%s%c%s%c%s%c%s%c%s%c%s%c%s%c%s%c(%s)%c(%s)%c(%s)";
176 
177 	register struct secXfer *	scptr;
178 
179 	LOGCHECK;
180 	scptr = &Xfer;			/* Point to security transfer data. */
181 	sprintf(Record, format,
182 		Type, FS,
183 		scptr->reqSystem, FS,
184 		scptr->reqUser, FS,
185 		scptr->desSystem, FS,
186 		scptr->desUser, FS,
187 		scptr->desFile, FS,
188 		scptr->srcSystem, FS,
189 		scptr->srcOwner, FS,
190 		scptr->srcFile, FS,
191 		scptr->srcSize, FS,
192 		scptr->srcMtime, FS,
193 		scptr->stime, FS,
194 		scptr->etime
195 	       );
196 
197 	/* Terminate the record and write it out. */
198 
199 	(void) strcat(Record, EOR);
200 	writeLog(Record,&LogFile,LogName,&Collecting);
201 	newRec(Type);
202 	return;
203 }
204 
205 /*
206  * Function:	scReqsys - log requestor system name
207  *
208  * Parameters:
209  *	reqsys: master machine name
210  */
211 
212 void
scReqsys(reqsys)213 scReqsys(reqsys)
214 char * reqsys;
215 
216 {
217 	register struct secXfer *	scptr = &Xfer;
218 
219 	LOGCHECK;
220 	copyText(scptr->reqSystem, sizeof(scptr->reqSystem), reqsys);
221 	return;
222 }
223 
224 /*
225  * Function:	scRequser - log requestor user name
226  *
227  * Parameters:
228  *	requser: one who issued the command
229  */
230 
231 void
scRequser(requser)232 scRequser(requser)
233 char * requser;
234 
235 {
236 	register struct secXfer *	scptr = &Xfer;
237 
238 	LOGCHECK;
239 	copyText(scptr->reqUser, sizeof(scptr->reqUser), requser);
240 	return;
241 }
242 
243 /*
244  * Function:	scStime - log start transfer time
245  *
246  */
247 
248 void
scStime()249 scStime()
250 
251 {
252 	register struct secXfer *	scptr = &Xfer;
253 
254 	LOGCHECK;
255 	copyText(scptr->stime, sizeof(scptr->stime), timeStamp());
256 	return;
257 }
258 
259 /*
260  * Function:	scEtime - log end transfer time
261  *
262  */
263 
264 void
scEtime()265 scEtime()
266 
267 {
268 	register struct secXfer *	scptr = &Xfer;
269 
270 	LOGCHECK;
271 	copyText(scptr->etime, sizeof(scptr->etime), timeStamp());
272 	return;
273 }
274 
275 /*
276  * Function:	scDest - log destination node, user and file name
277  *
278  * Parameters:
279  *	destsys: system where the dest file is sent to
280  *	destuser: user where the dest file is sent to
281  *	destfile: name of the dest file
282  *
283  */
284 
285 void
scDest(destsys,destuser,destfile)286 scDest(destsys, destuser, destfile)
287 char * destsys;
288 char * destuser;
289 char * destfile;
290 
291 {
292 	register struct secXfer *	scptr = &Xfer;
293 
294 	LOGCHECK;
295 	copyText(scptr->desSystem, sizeof(scptr->desSystem), destsys);
296 	copyText(scptr->desUser, sizeof(scptr->desUser), destuser);
297 	copyText(scptr->desFile, sizeof(scptr->desFile), destfile);
298 	return;
299 }
300 
301 /*
302  * Function:	scSrc - log source node, file owner, file name
303  *			modification time and size
304  *
305  * Parameters:
306  *	srcsys: system where the source file is recieved from
307  *	srcowner: owner of the source file
308  *	srcfile: name of the source file
309  *	srcmtime: modification date and time of source file
310  *	srcsize: size of the source file
311  *
312  */
313 
314 void
scSrc(srcsys,srcowner,srcfile,srcmtime,srcsize)315 scSrc(srcsys, srcowner, srcfile, srcmtime, srcsize)
316 char * srcsys;
317 char * srcowner;
318 char * srcfile;
319 char * srcmtime;
320 char * srcsize;
321 
322 {
323 	register struct secXfer *	scptr = &Xfer;
324 
325 	LOGCHECK;
326 	copyText(scptr->srcSystem, sizeof(scptr->srcSystem), srcsys);
327 	copyText(scptr->srcOwner, sizeof(scptr->srcOwner), srcowner );
328 	copyText(scptr->srcFile, sizeof(scptr->srcFile), srcfile);
329 	copyText(scptr->srcMtime, sizeof(scptr->srcMtime), srcmtime );
330 	copyText(scptr->srcSize, sizeof(scptr->srcSize), srcsize);
331 	return;
332 }
333 
334 /*
335  * Function:	scSize - get size of source file
336  *
337  * parameter	srcfile: name of the source file
338  *
339  */
340 
341 char *
scSize(srcfile)342 scSize(srcfile)
343 char * srcfile;
344 
345 {
346 	struct stat stbuf;
347 	static char size[MODSTR];
348 
349 	LOGCHECKC;
350 	if (stat(srcfile, &stbuf))
351     		return(NOTAVAIL);/* fail, set it ""  */
352 	sprintf(size,"%ld",stbuf.st_size);
353 	return(size);
354 }
355 
356 /*
357  * Function:	scOwn - get owner of source file
358  *
359  * parameter	srcfile: name of the source file
360  *
361  */
362 
363 char *
scOwn(srcfile)364 scOwn(srcfile)
365 char * srcfile;
366 
367 {
368 	struct stat stbuf;
369 	static char user[MODSTR];
370 
371 	LOGCHECKC;
372 	if (stat(srcfile, &stbuf))
373 		return(NOTAVAIL);
374 	(void) guinfo(stbuf.st_uid,user);
375 	return(user);
376 }
377 
378 /*
379  * Function:	scMtime - get modification date and time of source file
380  *
381  * parameter	srcfile: name of the source file
382  *
383  */
384 
385 char *
scMtime(srcfile)386 scMtime(srcfile)
387 char * srcfile;
388 
389 {
390 	struct stat stbuf;
391 	static char mtime[MODSTR];
392 	register struct tm *tp;
393 
394 	LOGCHECKC;
395 	if (stat(srcfile, &stbuf))
396 		return(NOTAVAIL);
397 	tp = localtime(&stbuf.st_mtime);
398 	(void) sprintf(mtime, "%d/%d-%d:%2.2d", tp->tm_mon + 1,
399 	    tp->tm_mday, tp->tm_hour, tp->tm_min);
400 	return(mtime);
401 }
402 
403 /*
404  * Function - scRexe: It is called when uuxqt is running
405  *
406  * Parameter:
407  *	clientsys - Client node name.
408  *	clientusr - Client user ID.
409  *	serverusr - Server user ID.
410  *	cmd - command to be execed by uuxqt
411  */
412 
413 void
scRexe(clientsys,clientusr,serverusr,cmd)414 scRexe(clientsys,clientusr,serverusr,cmd)
415 char * clientsys;
416 char * clientusr;
417 char * serverusr;
418 char * cmd;
419 {
420 	register struct secRexe *	scptr = &Rexe;
421 
422 
423 	LOGCHECK;
424 	copyText(scptr->cliSystem, sizeof(scptr->cliSystem), clientsys);
425 	copyText(scptr->cliUser, sizeof(scptr->cliUser), clientusr);
426 	copyText(scptr->serUser, sizeof(scptr->serUser), serverusr);
427 	copyText(scptr->time, sizeof(scptr->time), timeStamp());
428 	copyText(scptr->command, sizeof(scptr->command), cmd);
429 	return;
430 }
431 
432 /*
433  * Function - scWlog: It is called when the violation is occurred
434  *
435  */
436 
437 void
scWlog()438 scWlog()
439 {
440 	static char	format[] = "%s%c%s%c%s%c%s%c(%s)%c%s";
441 
442 	register struct secRexe *	scptr;
443 
444 	LOGCHECK;
445 	scptr = &Rexe;			/* Point to security remote exec data. */
446 	sprintf(Record, format,
447 		Type, FS,
448 		scptr->cliSystem, FS,
449 		scptr->cliUser, FS,
450 		scptr->serUser, FS,
451 		scptr->time, FS,
452 		scptr->command
453 	       );
454 
455 	/* Terminate the record and write it out. */
456 
457 	(void) strcat(Record, EOR);
458 	writeLog(Record,&LogFile,LogName,&Collecting);
459 	newRec(Type);
460 	return;
461 }
462