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