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