1
by Noah Meyerhans
Import upstream version 3.8.1p1 |
1 |
/*
|
2 |
* Copyright (c) 2000 Andre Lucas. All rights reserved.
|
|
3 |
*
|
|
4 |
* Redistribution and use in source and binary forms, with or without
|
|
5 |
* modification, are permitted provided that the following conditions
|
|
6 |
* are met:
|
|
7 |
* 1. Redistributions of source code must retain the above copyright
|
|
8 |
* notice, this list of conditions and the following disclaimer.
|
|
9 |
* 2. Redistributions in binary form must reproduce the above copyright
|
|
10 |
* notice, this list of conditions and the following disclaimer in the
|
|
11 |
* documentation and/or other materials provided with the distribution.
|
|
12 |
*
|
|
13 |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
14 |
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
15 |
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
16 |
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
17 |
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
18 |
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
19 |
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
20 |
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
21 |
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
22 |
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
23 |
*/
|
|
24 |
||
25 |
/**
|
|
26 |
** logintest.c: simple test driver for platform-independent login recording
|
|
27 |
** and lastlog retrieval
|
|
28 |
**/
|
|
29 |
||
30 |
#include "includes.h" |
|
31 |
||
32 |
#include <sys/types.h> |
|
33 |
#include <sys/wait.h> |
|
1.13.1
by Colin Watson
Import upstream version 4.6p1 |
34 |
#include <sys/socket.h> |
35 |
||
36 |
#include <netinet/in.h> |
|
37 |
||
1
by Noah Meyerhans
Import upstream version 3.8.1p1 |
38 |
#include <unistd.h> |
39 |
#include <stdlib.h> |
|
40 |
#include <stdio.h> |
|
41 |
#include <string.h> |
|
42 |
#include <pwd.h> |
|
43 |
#include <netdb.h> |
|
44 |
#ifdef HAVE_TIME_H
|
|
45 |
#include <time.h> |
|
46 |
#endif
|
|
47 |
||
48 |
#include "loginrec.h" |
|
49 |
||
50 |
extern char *__progname; |
|
51 |
||
52 |
#define PAUSE_BEFORE_LOGOUT 3
|
|
53 |
||
54 |
int nologtest = 0; |
|
55 |
int compile_opts_only = 0; |
|
56 |
int be_verbose = 0; |
|
57 |
||
58 |
||
59 |
/* Dump a logininfo to stdout. Assumes a tab size of 8 chars. */
|
|
60 |
void
|
|
61 |
dump_logininfo(struct logininfo *li, char *descname) |
|
62 |
{
|
|
63 |
/* yes I know how nasty this is */
|
|
64 |
printf("struct logininfo %s = {\n\t" |
|
65 |
"progname\t'%s'\n\ttype\t\t%d\n\t" |
|
66 |
"pid\t\t%d\n\tuid\t\t%d\n\t" |
|
67 |
"line\t\t'%s'\n\tusername\t'%s'\n\t" |
|
68 |
"hostname\t'%s'\n\texit\t\t%d\n\ttermination\t%d\n\t" |
|
69 |
"tv_sec\t%d\n\ttv_usec\t%d\n\t" |
|
70 |
"struct login_netinfo hostaddr {\n\t\t" |
|
71 |
"struct sockaddr sa {\n" |
|
72 |
"\t\t\tfamily\t%d\n\t\t}\n" |
|
73 |
"\t}\n" |
|
74 |
"}\n", |
|
75 |
descname, li->progname, li->type, |
|
76 |
li->pid, li->uid, li->line, |
|
77 |
li->username, li->hostname, li->exit, |
|
78 |
li->termination, li->tv_sec, li->tv_usec, |
|
79 |
li->hostaddr.sa.sa_family); |
|
80 |
}
|
|
81 |
||
82 |
||
83 |
int
|
|
84 |
testAPI() |
|
85 |
{
|
|
86 |
struct logininfo *li1; |
|
87 |
struct passwd *pw; |
|
88 |
struct hostent *he; |
|
89 |
struct sockaddr_in sa_in4; |
|
90 |
char cmdstring[256], stripline[8]; |
|
91 |
char username[32]; |
|
92 |
#ifdef HAVE_TIME_H
|
|
93 |
time_t t0, t1, t2, logintime, logouttime; |
|
94 |
char s_t0[64],s_t1[64],s_t2[64]; |
|
95 |
char s_logintime[64], s_logouttime[64]; /* ctime() strings */ |
|
96 |
#endif
|
|
97 |
||
98 |
printf("**\n** Testing the API...\n**\n"); |
|
99 |
||
100 |
pw = getpwuid(getuid()); |
|
101 |
strlcpy(username, pw->pw_name, sizeof(username)); |
|
102 |
||
103 |
/* gethostname(hostname, sizeof(hostname)); */
|
|
104 |
||
105 |
printf("login_alloc_entry test (no host info):\n"); |
|
106 |
||
107 |
/* FIXME fake tty more effectively - this could upset some platforms */
|
|
108 |
li1 = login_alloc_entry((int)getpid(), username, NULL, ttyname(0)); |
|
109 |
strlcpy(li1->progname, "OpenSSH-logintest", sizeof(li1->progname)); |
|
110 |
||
111 |
if (be_verbose) |
|
112 |
dump_logininfo(li1, "li1"); |
|
113 |
||
114 |
printf("Setting host address info for 'localhost' (may call out):\n"); |
|
115 |
if (! (he = gethostbyname("localhost"))) { |
|
116 |
printf("Couldn't set hostname(lookup failed)\n"); |
|
117 |
} else { |
|
118 |
/* NOTE: this is messy, but typically a program wouldn't have to set
|
|
119 |
* any of this, a sockaddr_in* would be already prepared */
|
|
120 |
memcpy((void *)&(sa_in4.sin_addr), (void *)&(he->h_addr_list[0][0]), |
|
121 |
sizeof(struct in_addr)); |
|
122 |
login_set_addr(li1, (struct sockaddr *) &sa_in4, sizeof(sa_in4)); |
|
123 |
strlcpy(li1->hostname, "localhost", sizeof(li1->hostname)); |
|
124 |
}
|
|
125 |
if (be_verbose) |
|
126 |
dump_logininfo(li1, "li1"); |
|
127 |
||
128 |
if ((int)geteuid() != 0) { |
|
129 |
printf("NOT RUNNING LOGIN TESTS - you are not root!\n"); |
|
130 |
return 1; |
|
131 |
}
|
|
132 |
||
133 |
if (nologtest) |
|
134 |
return 1; |
|
135 |
||
136 |
line_stripname(stripline, li1->line, sizeof(stripline)); |
|
137 |
||
138 |
printf("Performing an invalid login attempt (no type field)\n--\n"); |
|
139 |
login_write(li1); |
|
140 |
printf("--\n(Should have written errors to stderr)\n"); |
|
141 |
||
142 |
#ifdef HAVE_TIME_H
|
|
143 |
(void)time(&t0); |
|
144 |
strlcpy(s_t0, ctime(&t0), sizeof(s_t0)); |
|
145 |
t1 = login_get_lastlog_time(getuid()); |
|
146 |
strlcpy(s_t1, ctime(&t1), sizeof(s_t1)); |
|
147 |
printf("Before logging in:\n\tcurrent time is %d - %s\t" |
|
148 |
"lastlog time is %d - %s\n", |
|
149 |
(int)t0, s_t0, (int)t1, s_t1); |
|
150 |
#endif
|
|
151 |
||
152 |
printf("Performing a login on line %s ", stripline); |
|
153 |
#ifdef HAVE_TIME_H
|
|
154 |
(void)time(&logintime); |
|
155 |
strlcpy(s_logintime, ctime(&logintime), sizeof(s_logintime)); |
|
156 |
printf("at %d - %s", (int)logintime, s_logintime); |
|
157 |
#endif
|
|
158 |
printf("--\n"); |
|
159 |
login_login(li1); |
|
160 |
||
161 |
snprintf(cmdstring, sizeof(cmdstring), "who | grep '%s '", |
|
162 |
stripline); |
|
163 |
system(cmdstring); |
|
164 |
||
165 |
printf("--\nPausing for %d second(s)...\n", PAUSE_BEFORE_LOGOUT); |
|
166 |
sleep(PAUSE_BEFORE_LOGOUT); |
|
167 |
||
168 |
printf("Performing a logout "); |
|
169 |
#ifdef HAVE_TIME_H
|
|
170 |
(void)time(&logouttime); |
|
171 |
strlcpy(s_logouttime, ctime(&logouttime), sizeof(s_logouttime)); |
|
172 |
printf("at %d - %s", (int)logouttime, s_logouttime); |
|
173 |
#endif
|
|
174 |
printf("\nThe root login shown above should be gone.\n" |
|
175 |
"If the root login hasn't gone, but another user on the same\n" |
|
176 |
"pty has, this is OK - we're hacking it here, and there\n" |
|
177 |
"shouldn't be two users on one pty in reality...\n" |
|
178 |
"-- ('who' output follows)\n"); |
|
179 |
login_logout(li1); |
|
180 |
||
181 |
system(cmdstring); |
|
182 |
printf("-- ('who' output ends)\n"); |
|
183 |
||
184 |
#ifdef HAVE_TIME_H
|
|
185 |
t2 = login_get_lastlog_time(getuid()); |
|
186 |
strlcpy(s_t2, ctime(&t2), sizeof(s_t2)); |
|
187 |
printf("After logging in, lastlog time is %d - %s\n", (int)t2, s_t2); |
|
188 |
if (t1 == t2) |
|
189 |
printf("The lastlog times before and after logging in are the " |
|
190 |
"same.\nThis indicates that lastlog is ** NOT WORKING " |
|
191 |
"CORRECTLY **\n"); |
|
192 |
else if (t0 != t2) |
|
193 |
/* We can be off by a second or so, even when recording works fine.
|
|
194 |
* I'm not 100% sure why, but it's true. */
|
|
195 |
printf("** The login time and the lastlog time differ.\n" |
|
196 |
"** This indicates that lastlog is either recording the "
|
|
197 |
"wrong time,\n** or retrieving the wrong entry.\n" |
|
198 |
"If it's off by less than %d second(s) "
|
|
199 |
"run the test again.\n", PAUSE_BEFORE_LOGOUT); |
|
200 |
else
|
|
201 |
printf("lastlog agrees with the login time. This is a good thing.\n"); |
|
202 |
||
203 |
#endif
|
|
204 |
||
205 |
printf("--\nThe output of 'last' shown next should have " |
|
206 |
"an entry for root \n on %s for the time shown above:\n--\n", |
|
207 |
stripline); |
|
208 |
snprintf(cmdstring, sizeof(cmdstring), "last | grep '%s ' | head -3", |
|
209 |
stripline); |
|
210 |
system(cmdstring); |
|
211 |
||
212 |
printf("--\nEnd of login test.\n"); |
|
213 |
||
214 |
login_free_entry(li1); |
|
215 |
||
216 |
return 1; |
|
217 |
} /* testAPI() */ |
|
218 |
||
219 |
||
220 |
void
|
|
221 |
testLineName(char *line) |
|
222 |
{
|
|
223 |
/* have to null-terminate - these functions are designed for
|
|
224 |
* structures with fixed-length char arrays, and don't null-term.*/
|
|
225 |
char full[17], strip[9], abbrev[5]; |
|
226 |
||
227 |
memset(full, '\0', sizeof(full)); |
|
228 |
memset(strip, '\0', sizeof(strip)); |
|
229 |
memset(abbrev, '\0', sizeof(abbrev)); |
|
230 |
||
231 |
line_fullname(full, line, sizeof(full)-1); |
|
232 |
line_stripname(strip, full, sizeof(strip)-1); |
|
233 |
line_abbrevname(abbrev, full, sizeof(abbrev)-1); |
|
234 |
printf("%s: %s, %s, %s\n", line, full, strip, abbrev); |
|
235 |
||
236 |
} /* testLineName() */ |
|
237 |
||
238 |
||
239 |
int
|
|
240 |
testOutput() |
|
241 |
{
|
|
242 |
printf("**\n** Testing linename functions\n**\n"); |
|
243 |
testLineName("/dev/pts/1"); |
|
244 |
testLineName("pts/1"); |
|
245 |
testLineName("pts/999"); |
|
246 |
testLineName("/dev/ttyp00"); |
|
247 |
testLineName("ttyp00"); |
|
248 |
||
249 |
return 1; |
|
250 |
} /* testOutput() */ |
|
251 |
||
252 |
||
253 |
/* show which options got compiled in */
|
|
254 |
void
|
|
255 |
showOptions(void) |
|
256 |
{
|
|
257 |
printf("**\n** Compile-time options\n**\n"); |
|
258 |
||
259 |
printf("login recording methods selected:\n"); |
|
260 |
#ifdef USE_LOGIN
|
|
261 |
printf("\tUSE_LOGIN\n"); |
|
262 |
#endif
|
|
263 |
#ifdef USE_UTMP
|
|
264 |
printf("\tUSE_UTMP (UTMP_FILE=%s)\n", UTMP_FILE); |
|
265 |
#endif
|
|
266 |
#ifdef USE_UTMPX
|
|
267 |
printf("\tUSE_UTMPX (UTMPX_FILE=%s)\n", UTMPX_FILE); |
|
268 |
#endif
|
|
269 |
#ifdef USE_WTMP
|
|
270 |
printf("\tUSE_WTMP (WTMP_FILE=%s)\n", WTMP_FILE); |
|
271 |
#endif
|
|
272 |
#ifdef USE_WTMPX
|
|
273 |
printf("\tUSE_WTMPX (WTMPX_FILE=%s)\n", WTMPX_FILE); |
|
274 |
#endif
|
|
275 |
#ifdef USE_LASTLOG
|
|
276 |
printf("\tUSE_LASTLOG (LASTLOG_FILE=%s)\n", LASTLOG_FILE); |
|
277 |
#endif
|
|
278 |
printf("\n"); |
|
279 |
||
280 |
} /* showOptions() */ |
|
281 |
||
282 |
||
283 |
int
|
|
284 |
main(int argc, char *argv[]) |
|
285 |
{
|
|
286 |
printf("Platform-independent login recording test driver\n"); |
|
287 |
||
288 |
__progname = ssh_get_progname(argv[0]); |
|
289 |
if (argc == 2) { |
|
290 |
if (strncmp(argv[1], "-i", 3) == 0) |
|
291 |
compile_opts_only = 1; |
|
292 |
else if (strncmp(argv[1], "-v", 3) == 0) |
|
293 |
be_verbose=1; |
|
294 |
}
|
|
295 |
||
296 |
if (!compile_opts_only) { |
|
297 |
if (be_verbose && !testOutput()) |
|
298 |
return 1; |
|
299 |
||
300 |
if (!testAPI()) |
|
301 |
return 1; |
|
302 |
}
|
|
303 |
||
304 |
showOptions(); |
|
305 |
||
306 |
return 0; |
|
307 |
} /* main() */ |
|
308 |