0e9e3aaaf1e59d80b6eedd2e6a233890dd276ef7
[openafs.git] / src / libafscp / afscp_util.c
1 /* AUTORIGHTS
2 Copyright (C) 2003 - 2010 Chaskiel Grundman
3 Copyright (c) 2011 Your Filesystem Inc.
4 Copyright (c) 2012 Sine Nomine Associates
5 All rights reserved
6
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions
9 are met:
10
11 1. Redistributions of source code must retain the above copyright
12    notice, this list of conditions and the following disclaimer.
13
14 2. Redistributions in binary form must reproduce the above copyright
15    notice, this list of conditions and the following disclaimer in the
16    documentation and/or other materials provided with the distribution.
17
18 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29 #include <afsconfig.h>
30 #include <afs/param.h>
31
32 #include <roken.h>
33
34 #include <ctype.h>
35 #include <afs/cellconfig.h>
36 #ifndef AFSCONF_CLIENTNAME
37 #include <afs/dirpath.h>
38 #define AFSCONF_CLIENTNAME AFSDIR_CLIENT_ETC_DIRPATH
39 #endif
40 #include <ubik.h>
41 #include <rx/rx_null.h>
42 #include <rx/rxkad.h>
43 #ifdef HAVE_KERBEROS
44 # include <krb5.h>
45 #endif
46 #include "afscp.h"
47 #include "afscp_internal.h"
48
49 #define HC_DEPRECATED
50 #include <hcrypto/des.h>
51
52 #ifdef HAVE_KRB5_CREDS_KEYBLOCK_ENCTYPE
53 #define Z_keydata(keyblock)     ((keyblock)->contents)
54 #define Z_keylen(keyblock)      ((keyblock)->length)
55 #define Z_credskey(creds)       (&(creds)->keyblock)
56 #define Z_enctype(keyblock)     ((keyblock)->enctype)
57 #else
58 #define Z_keydata(keyblock)     ((keyblock)->keyvalue.data)
59 #define Z_keylen(keyblock)      ((keyblock)->keyvalue.length)
60 #define Z_credskey(creds)       (&(creds)->session)
61 #define Z_enctype(keyblock)     ((keyblock)->keytype)
62 #endif
63
64 static int insecure = 0;
65 static int try_anonymous = 0;
66 static char authas_name[256];
67 static char authas_inst[256];
68
69 int
70 afscp_Insecure(void)
71 {
72     insecure = 1;
73     return 0;
74 }
75
76 int
77 afscp_AnonymousAuth(int state)
78 {
79     try_anonymous = state;
80     return 0;
81 }
82
83 /**
84  * Connect to all servers using authenticated connections, using the local
85  * KeyFile to appear as an arbitrary user.
86  *
87  * @param[in] aname  The pts username to impersonate
88  *
89  * @note aname is krb4-based name, not a krb5 principal. So for example, you
90  *       probably want to give "user.admin" instead of "user/admin".
91  *
92  * @return operation status
93  *  @retval 0 success
94  */
95 int
96 afscp_LocalAuthAs(const char *aname)
97 {
98     const char *ainst = strchr(aname, '.');
99     size_t namelen, instlen;
100
101     if (ainst) {
102         namelen = ainst - aname;
103         ainst++;
104         instlen = strlen(ainst);
105     } else {
106         namelen = strlen(aname);
107         ainst = "";
108         instlen = 0;
109     }
110
111     if (namelen+1 > sizeof(authas_name) || instlen+1 > sizeof(authas_inst)) {
112         return EINVAL;
113     }
114     strncpy(authas_name, aname, namelen);
115     strncpy(authas_inst, ainst, instlen);
116     return 0;
117 }
118
119 static struct afsconf_dir *confdir;
120
121 void
122 afscp_SetConfDir(char *confDir)
123 {
124     if (confdir != NULL)
125         afsconf_Close(confdir);
126
127     confdir = afsconf_Open(confDir);
128 }
129
130 static int
131 _GetCellInfo(char *cell, struct afsconf_cell *celldata)
132 {
133     int code;
134     if (confdir == NULL)
135         confdir = afsconf_Open(AFSCONF_CLIENTNAME);
136     if (confdir == NULL) {
137         return AFSCONF_NODB;
138     }
139     code = afsconf_GetCellInfo(confdir, cell, AFSCONF_VLDBSERVICE, celldata);
140     return code;
141 }
142
143 static int
144 _GetNullSecurityObject(struct afscp_cell *cell)
145 {
146     cell->security = (struct rx_securityClass *)rxnull_NewClientSecurityObject();
147     cell->scindex = RX_SECIDX_NULL;
148     return 0;
149 }
150
151 static int
152 _GetLocalSecurityObject(struct afscp_cell *cell,
153                         char *aname, char *ainst)
154 {
155     int code = 0;
156     char tbuffer[256];
157     struct ktc_encryptionKey key, session;
158     struct rx_securityClass *tc;
159     afs_int32 kvno;
160     afs_int32 ticketLen;
161     rxkad_level lev;
162     struct afsconf_dir *tdir;
163
164     tdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
165     if (!tdir) {
166         code = AFSCONF_FAILURE;
167         goto done;
168     }
169
170     code = afsconf_GetLatestKey(tdir, &kvno, &key);
171     if (code) {
172         goto done;
173     }
174
175     DES_init_random_number_generator((DES_cblock *)&key);
176     code = DES_new_random_key((DES_cblock *)&session);
177     if (code) {
178         goto done;
179     }
180
181     ticketLen = sizeof(tbuffer);
182     memset(tbuffer, 0, sizeof(tbuffer));
183     code = tkt_MakeTicket(tbuffer, &ticketLen, &key, aname, ainst, "", 0,
184                           0xffffffff, &session, 0, "afs", "");
185     if (code) {
186         goto done;
187     }
188
189     if (insecure) {
190         lev = rxkad_clear;
191     } else {
192         lev = rxkad_crypt;
193     }
194
195     tc = (struct rx_securityClass *)
196         rxkad_NewClientSecurityObject(lev, &session, kvno, ticketLen,
197                                       tbuffer);
198     if (!tc) {
199         code = RXKADBADKEY;
200         goto done;
201     }
202
203     cell->security = tc;
204     cell->scindex = 2;
205
206  done:
207     if (tdir) {
208         afsconf_Close(tdir);
209     }
210     return code;
211 }
212
213 int
214 _GetSecurityObject(struct afscp_cell *cell)
215 {
216     int code = ENOENT;
217 #ifdef HAVE_KERBEROS
218     krb5_context context;
219     krb5_creds match;
220     krb5_creds *cred;
221     krb5_ccache cc;
222     char **realms, *realm;
223     struct afsconf_cell celldata;
224     char localcell[MAXCELLCHARS + 1];
225     struct rx_securityClass *sc;
226     struct ktc_encryptionKey k;
227     int i;
228     rxkad_level l;
229     code = _GetCellInfo(cell->name, &celldata);
230     if (code != 0) {
231         goto try_anon;
232     }
233
234     if (authas_name[0]) {
235         code = _GetLocalSecurityObject(cell, authas_name, authas_inst);
236         if (code == 0) {
237             return 0;
238         }
239     }
240
241     code = krb5_init_context(&context); /* see aklog.c main() */
242     if (code != 0) {
243         goto try_anon;
244     }
245
246     if (cell->realm == NULL) {
247         realm = NULL;
248         code = krb5_get_host_realm(context, celldata.hostName[0], &realms);
249
250         if (code == 0) {
251             strlcpy(localcell, realms[0], sizeof(localcell));
252             krb5_free_host_realm(context, realms);
253             realm = localcell;
254         } else
255             goto try_anon;
256     } else {
257         realm = cell->realm;
258         strlcpy(localcell, realm, MAXCELLCHARS + 1);
259     }
260     if (realm)
261         if (realm == NULL) {
262             for (i = 0; (i < MAXCELLCHARS && cell->name[i]); i++) {
263                 if (isalpha(cell->name[i]))
264                     localcell[i] = toupper(cell->name[i]);
265                 else
266                     localcell[i] = cell->name[i];
267             }
268             localcell[i] = '\0';
269             realm = localcell;
270         }
271     cc = NULL;
272     code = krb5_cc_default(context, &cc);
273
274     memset(&match, 0, sizeof(match));
275     Z_enctype(Z_credskey(&match)) = ENCTYPE_DES_CBC_CRC;
276
277     if (code == 0)
278         code = krb5_cc_get_principal(context, cc, &match.client);
279     if (code == 0)
280         code = krb5_build_principal(context, &match.server,
281                                     strlen(realm), realm,
282                                     "afs", cell->name, NULL);
283
284     if (code != 0) {
285         krb5_free_cred_contents(context, &match);
286         if (cc)
287             krb5_cc_close(context, cc);
288         krb5_free_context(context);
289         goto try_anon;
290     }
291
292     code = krb5_get_credentials(context, 0, cc, &match, &cred);
293     if (code != 0) {
294         krb5_free_principal(context, match.server);
295         match.server = NULL;
296
297         code = krb5_build_principal(context, &match.server,
298                                     strlen(realm), realm, "afs", NULL);
299         if (code == 0)
300             code = krb5_get_credentials(context, 0, cc, &match, &cred);
301         if (code != 0) {
302             krb5_free_cred_contents(context, &match);
303             if (cc)
304                 krb5_cc_close(context, cc);
305             krb5_free_context(context);
306             goto try_anon;
307         }
308     }
309
310     if (insecure)
311         l = rxkad_clear;
312     else
313         l = rxkad_crypt;
314     memcpy(&k.data, Z_keydata(Z_credskey(cred)), 8);
315     sc = (struct rx_securityClass *)rxkad_NewClientSecurityObject
316         (l, &k, RXKAD_TKT_TYPE_KERBEROS_V5,
317          cred->ticket.length, cred->ticket.data);
318     krb5_free_creds(context, cred);
319     krb5_free_cred_contents(context, &match);
320     if (cc)
321         krb5_cc_close(context, cc);
322     krb5_free_context(context);
323     cell->security = sc;
324     cell->scindex = 2;
325     return 0;
326
327     try_anon:
328 #endif /* HAVE_KERBEROS */
329     if (try_anonymous)
330         return _GetNullSecurityObject(cell);
331     else
332         return code;
333 }
334
335 int
336 _GetVLservers(struct afscp_cell *cell)
337 {
338     struct rx_connection *conns[MAXHOSTSPERCELL + 1];
339     int i;
340     int code;
341     struct afsconf_cell celldata;
342
343     code = _GetCellInfo(cell->name, &celldata);
344     if (code != 0) {
345         return code;
346     }
347
348     for (i = 0; i < celldata.numServers; i++) {
349         conns[i] = rx_NewConnection(celldata.hostAddr[i].sin_addr.s_addr,
350                                     htons(AFSCONF_VLDBPORT),
351                                     USER_SERVICE_ID, cell->security,
352                                     cell->scindex);
353     }
354     conns[i] = 0;
355     return ubik_ClientInit(conns, &cell->vlservers);
356 }