Revert "Add some basic tests to check out fuse"
[openafs.git] / tests / auth / superuser-t.c
1 /*
2  * Copyright (c) 2010 Your File System Inc. 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 #include <afsconfig.h>
25 #include <afs/param.h>
26
27 #include <roken.h>
28
29 #ifdef HAVE_SYS_WAIT_H
30 #include <sys/wait.h>
31 #endif
32
33 #ifdef IGNORE_SOME_GCC_WARNINGS
34 # pragma GCC diagnostic warning "-Wdeprecated-declarations"
35 #endif
36
37 #include <afs/cellconfig.h>
38 #include <afs/afsutil.h>
39 #include <afs/com_err.h>
40
41 #include <rx/rxkad.h>
42 #include <rx/rx_identity.h>
43
44 #include <hcrypto/des.h>
45 #include <tests/tap/basic.h>
46
47 #include "test.h"
48 #include "common.h"
49
50 #define TEST_PORT 1234
51
52 static void
53 testOriginalIterator(struct afsconf_dir *dir, int num, char *user) {
54     char buffer[256];
55
56     ok((afsconf_GetNthUser(dir, num, buffer, sizeof buffer) == 0),
57        "User %d successfully returned as %s", num, buffer);
58
59     ok(strcmp(user, buffer) == 0,
60        "User %d matches", num);
61 }
62
63 static void
64 testNewIterator(struct afsconf_dir *dir, int num, struct rx_identity *id) {
65     struct rx_identity *fileId;
66
67     ok((afsconf_GetNthIdentity(dir, num, &fileId) == 0),
68        "Identity %d successfully returned", num);
69
70     ok(rx_identity_match(fileId, id), "Identity %d matches", num);
71
72     rx_identity_free(&fileId);
73 }
74
75
76 void
77 startClient(char *configPath)
78 {
79     struct afsconf_dir *dir;
80     struct rx_identity *testId, *anotherId, *extendedId, *dummy;
81     struct rx_securityClass *class;
82     struct rx_connection *conn;
83     afs_uint32 startTime;
84     char ubuffer[256];
85     afs_int32 classIndex;
86     int code;
87     struct hostent *he;
88     afs_uint32 addr;
89     afs_int32 result;
90     char *string = NULL;
91
92     plan(63);
93
94     dir = afsconf_Open(configPath);
95     ok(dir!=NULL,
96        "Configuration directory opened sucessfully by client");
97
98     /* Add a normal user to the super user file */
99     ok(afsconf_AddUser(dir, "test") == 0,
100        "Adding a simple user works");
101
102     testId = rx_identity_new(RX_ID_KRB4, "test", "test", strlen("test"));
103
104     /* Check that they are a super user */
105     ok(afsconf_IsSuperIdentity(dir, testId),
106        "User added with old i/face is identitifed as super user");
107
108     /* Check that nobody else is */
109     ok(!afsconf_IsSuperIdentity(dir,
110                                rx_identity_new(RX_ID_KRB4, "testy",
111                                                "testy", strlen("testy"))),
112        "Additional users are not super users");
113
114     ok(afsconf_AddUser(dir, "test") == EEXIST,
115        "Adding a user that already exists fails");
116
117     ok(afsconf_AddIdentity(dir, testId) == EEXIST,
118        "Adding an identity that already exists fails");
119
120     anotherId = rx_identity_new(RX_ID_KRB4, "another",
121                                             "another", strlen("another"));
122
123     /* Add another normal user, but using the extended interface */
124     ok(afsconf_AddIdentity(dir, anotherId) == 0,
125        "Adding a KRB4 identity works");
126
127     /* Check that they are a super user */
128     ok(afsconf_IsSuperIdentity(dir, anotherId),
129        "User added with new i/face is identitifed as super user");
130
131     ok(afsconf_AddIdentity(dir, anotherId) == EEXIST,
132        "Adding a KRB4 identity that already exists fails");
133
134     /* Add an extended user to the super user file */
135     extendedId = rx_identity_new(RX_ID_GSS, "sxw@INF.ED.AC.UK",
136                                  "\x04\x01\x00\x0B\x06\x09\x2A\x86\x48\x86\xF7\x12\x01\x02\x02\x00\x00\x00\x10sxw@INF.ED.AC.UK", 35);
137
138     ok(afsconf_AddIdentity(dir, extendedId) == 0,
139        "Adding a GSSAPI identity works");
140
141     /* Check that they are now special */
142     ok(afsconf_IsSuperIdentity(dir, extendedId),
143        "Added GSSAPI identity is a super user");
144
145     /* Check that display name isn't used for matches */
146     ok(!afsconf_IsSuperIdentity(dir,
147                                 rx_identity_new(RX_ID_GSS, "sxw@INF.ED.AC.UK",
148                                                 "abcdefghijklmnopqrstuvwxyz123456789", 35)),
149        "Display name is not used for extended matches");
150
151     ok(afsconf_AddIdentity(dir, extendedId) == EEXIST,
152        "Adding GSSAPI identity twice fails");
153
154     /* Add a final normal user, so we can check that iteration works */
155     /* Add a normal user to the super user file */
156     ok(afsconf_AddUser(dir, "test2") == 0,
157        "Adding another simple user works");
158
159     testOriginalIterator(dir, 0, "test");
160     testOriginalIterator(dir, 1, "another");
161     testOriginalIterator(dir, 2, "test2");
162     ok(afsconf_GetNthUser(dir, 3, ubuffer, sizeof ubuffer) != 0,
163        "Reading past the end of the superuser list fails");
164
165     testNewIterator(dir, 0, testId);
166     testNewIterator(dir, 1, anotherId);
167     testNewIterator(dir, 2, extendedId);
168     testNewIterator(dir, 3, rx_identity_new(RX_ID_KRB4, "test2",
169                                             "test2", strlen("test2")));
170     ok(afsconf_GetNthIdentity(dir, 4, &dummy) != 0,
171        "Reading past the end of the superuser list fails");
172
173     ok(afsconf_DeleteUser(dir, "notthere") != 0,
174        "Deleting a user that doesn't exist fails");
175
176     /* Delete the normal user */
177     ok(afsconf_DeleteUser(dir, "another") == 0,
178        "Deleting normal user works");
179
180     ok(!afsconf_IsSuperIdentity(dir, anotherId),
181        "Deleted user is no longer super user");
182
183     ok(afsconf_IsSuperIdentity(dir, testId) &&
184        afsconf_IsSuperIdentity(dir, extendedId),
185        "Other identities still are");
186
187     ok(afsconf_DeleteIdentity(dir, extendedId) == 0,
188        "Deleting identity works");
189
190     ok(!afsconf_IsSuperIdentity(dir, extendedId),
191        "Deleted identity is no longer special");
192
193     /* Now, what happens if we're doing something over the network instead */
194
195     code = rx_Init(0);
196     is_int(code, 0, "Initialised RX");
197
198     /* Fake up an rx ticket. Note that this will be for the magic 'superuser' */
199     code = afsconf_ClientAuth(dir, &class, &classIndex);
200     is_int(code, 0, "Can successfully create superuser token");
201
202     /* Start a connection to our test service with it */
203     he = gethostbyname("localhost");
204     if (!he) {
205         printf("Couldn't look up server hostname");
206         exit(1);
207     }
208
209     memcpy(&addr, he->h_addr, sizeof(afs_uint32));
210
211     conn = rx_NewConnection(addr, htons(TEST_PORT), TEST_SERVICE_ID,
212                             class, classIndex);
213
214     /* There's nothing in the list, so this just succeeds because we can */
215     code = TEST_CanI(conn, &result);
216     is_int(0, code, "Can run a simple RPC");
217
218     code = TEST_WhoAmI(conn, &string);
219     is_int(0, code, "Can get identity back");
220     is_string("<LocalAuth>", string, "Forged token is super user");
221
222     xdr_free((xdrproc_t)xdr_string, &string);
223
224     /* Throw away this connection and security class */
225     rx_DestroyConnection(conn);
226     rxs_Release(class);
227
228     /* Now fake an rx ticket for a normal user. We have to do more work by hand
229      * here, sadly */
230
231     startTime = time(NULL);
232     class = afstest_FakeRxkadClass(dir, "rpctest", "", "", startTime,
233                                    startTime + 60* 60);
234
235     conn = rx_NewConnection(addr, htons(TEST_PORT), TEST_SERVICE_ID, class,
236                             RX_SECIDX_KAD);
237
238     code = TEST_CanI(conn, &result);
239     is_int(EPERM, code,
240            "Running RPC as non-super user fails as expected");
241     code = TEST_NewCanI(conn, &result);
242     is_int(EPERM, code,
243            "Running new interface RPC as non-super user fails as expected");
244     code = TEST_WhoAmI(conn, &string);
245     xdr_free((xdrproc_t)xdr_string, &string);
246     is_int(EPERM, code,
247            "Running RPC returning string fails as expected");
248     code = TEST_NewWhoAmI(conn, &string);
249     xdr_free((xdrproc_t)xdr_string, &string);
250     is_int(EPERM, code,
251            "Running new interface RPC returning string fails as expected");
252     ok(afsconf_AddUser(dir, "rpctest") == 0,
253        "Adding %s user works", "rpctest");
254     code = TEST_CanI(conn, &result);
255     is_int(0, code, "Running RPC as rpctest works");
256     code = TEST_NewCanI(conn, &result);
257     is_int(0, code, "Running new interface RPC as rpctest works");
258     code = TEST_WhoAmI(conn, &string);
259     is_int(0, code, "Running RPC returning string as %s works", "rpctest");
260     is_string("rpctest", string, "Returned user string matches");
261     xdr_free((xdrproc_t)xdr_string, &string);
262     code = TEST_NewWhoAmI(conn, &string);
263     is_int(0, code, "Running new RPC returning string as %s works", "rpctest");
264     is_string("rpctest", string, "Returned user string for new interface matches");
265     xdr_free((xdrproc_t)xdr_string, &string);
266     rx_DestroyConnection(conn);
267     rxs_Release(class);
268
269     /* Now try with an admin principal */
270     startTime = time(NULL);
271     class = afstest_FakeRxkadClass(dir, "rpctest", "admin", "", startTime,
272                                    startTime + 60* 60);
273
274     conn = rx_NewConnection(addr, htons(TEST_PORT), TEST_SERVICE_ID, class,
275                             RX_SECIDX_KAD);
276
277     code = TEST_CanI(conn, &result);
278     is_int(EPERM, code,
279            "Running RPC as non-super user fails as expected");
280     code = TEST_NewCanI(conn, &result);
281     is_int(EPERM, code,
282            "Running new interface RPC as non-super user fails as expected");
283     code = TEST_WhoAmI(conn, &string);
284     xdr_free((xdrproc_t)xdr_string, &string);
285     is_int(EPERM, code,
286            "Running RPC returning string fails as expected");
287     code = TEST_NewWhoAmI(conn, &string);
288     xdr_free((xdrproc_t)xdr_string, &string);
289     is_int(EPERM, code,
290            "Running new interface RPC returning string fails as expected");
291
292     ok(afsconf_AddUser(dir, "rpctest.admin") == 0,
293        "Adding %s user works", "rpctest.admin");
294
295     code = TEST_CanI(conn, &result);
296     is_int(0, code, "Running RPC as %s works", "rpctest/admin");
297     code = TEST_NewCanI(conn, &result);
298     is_int(0, code, "Running new interface RPC as %s works", "rpctest/admin");
299     code = TEST_WhoAmI(conn, &string);
300     is_int(0, code, "Running RPC returning string as %s works", "rpctest/admin");
301     is_string("rpctest.admin", string, "Returned user string matches");
302     xdr_free((xdrproc_t)xdr_string, &string);
303     code = TEST_NewWhoAmI(conn, &string);
304     is_int(0, code, "Running new interface RPC returning string as %s works",
305            "rpctest/admin");
306     is_string("rpctest.admin", string,
307               "Returned user string from new interface matches");
308     xdr_free((xdrproc_t)xdr_string, &string);
309
310     rx_DestroyConnection(conn);
311     rxs_Release(class);
312 }
313
314 /**********************************************************************
315  * Server
316  **********************************************************************/
317
318 struct afsconf_dir *globalDir;
319
320 int
321 STEST_CanI(struct rx_call *call, afs_int32 *result)
322 {
323     *result = 0;
324     if (!afsconf_SuperUser(globalDir, call, NULL)) {
325         return EPERM;
326     }
327     return 0;
328 }
329
330 int
331 STEST_NewCanI(struct rx_call *call, afs_int32 *result)
332 {
333     *result = 0;
334     if (!afsconf_SuperIdentity(globalDir, call, NULL)) {
335         return EPERM;
336     }
337     return 0;
338 }
339
340 int
341 STEST_WhoAmI(struct rx_call *call, char **result)
342 {
343    char string[MAXKTCNAMELEN];
344
345    if (!afsconf_SuperUser(globalDir, call, string)) {
346         *result = strdup("");
347         return EPERM;
348    }
349    *result = strdup(string);
350
351    return 0;
352 }
353
354 int
355 STEST_NewWhoAmI(struct rx_call *call, char **result)
356 {
357    struct rx_identity *id;
358
359    if (!afsconf_SuperIdentity(globalDir, call, &id)) {
360         *result = strdup("");
361         return EPERM;
362    }
363    *result = strdup(id->displayName);
364
365    return 0;
366 }
367
368 int main(int argc, char **argv)
369 {
370     struct afsconf_dir *dir;
371     char *dirname;
372     int serverPid, clientPid, waited, stat;
373     int code;
374
375     /* Start the client and the server if requested */
376
377     if (argc == 3 ) {
378         if (strcmp(argv[1], "-server") == 0) {
379             globalDir = afsconf_Open(argv[2]);
380             afstest_StartTestRPCService(argv[2], TEST_PORT, TEST_SERVICE_ID,
381                                         TEST_ExecuteRequest);
382             exit(0);
383         } else if (strcmp(argv[1], "-client") == 0) {
384             startClient(argv[2]);
385             exit(0);
386         } else {
387             printf("Bad option %s\n", argv[1]);
388             exit(1);
389         }
390     }
391
392     /* Otherwise, do the basic configuration, then start the client and
393      * server */
394
395     dirname = afstest_BuildTestConfig();
396
397     dir = afsconf_Open(dirname);
398     if (dir == NULL) {
399         fprintf(stderr, "Unable to configure directory.\n");
400         exit(1);
401     }
402
403     code = afstest_AddDESKeyFile(dir);
404     if (code) {
405         afs_com_err("superuser-t", code, "while adding new key\n");
406         exit(1);
407     }
408
409     printf("Config directory is %s\n", dirname);
410     serverPid = fork();
411     if (serverPid == -1) {
412         /* Bang */
413     } else if (serverPid == 0) {
414         execl(argv[0], argv[0], "-server", dirname, NULL);
415         exit(1);
416     }
417     clientPid = fork();
418     if (clientPid == -1) {
419         kill(serverPid, SIGTERM);
420         waitpid(serverPid, &stat, 0);
421         exit(1);
422     } else if (clientPid == 0) {
423         execl(argv[0], argv[0], "-client", dirname, NULL);
424     }
425
426     do {
427         waited = waitpid(0, &stat, 0);
428     } while(waited == -1 && errno == EINTR);
429
430     if (waited == serverPid) {
431         kill(clientPid, SIGTERM);
432     } else if (waited == clientPid) {
433         kill(serverPid, SIGTERM);
434     }
435     waitpid(0, &stat, 0);
436
437     /* Client and server are both done, so cleanup after everything */
438
439     /* unlinkTestConfig(dirname); */
440
441     return 0;
442 }