← Back to branch summary

~ubuntu-branches/ubuntu/maverick/krb5/maverick

« back to all changes in this revision

Viewing changes to src/lib/krb4/mac_stubs.c

  • Committer: Bazaar Package Importer
  • Author(s): Sam Hartman
  • Date: 2009-05-07 16:16:34 UTC
  • mfrom: (13.1.7 sid)
  • Revision ID: james.westby@ubuntu.com-20090507161634-xqyk0s9na0le4flj
Tags: 1.7dfsg~beta1-4
http://bugs.debian.org/527353
When  decrypting the TGS response fails with the subkey, try with the
session key to work around Heimdal bug, Closes: #527353 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/krb4/mac_stubs.c
1
 
/* 
2
 
 * mac_stubs.c
3
 
 *
4
 
 * For copying and distribution information, please see the file
5
 
 * <mit-copyright.h>.
6
 
 *
7
 
 * Macintosh oopserating system stub interface for Kerberos.
8
 
 * Applications call these routines, which then call the driver to do the work.
9
 
 */
10
 
 
11
 
#include "krb.h"
12
 
#include "krb_driver.h" /* Mac driver interface */
13
 
 
14
 
#include <string.h>
15
 
#include <stddef.h>
16
 
#include <Files.h>
17
 
#include <Devices.h>
18
 
 
19
 
/* We export the driver reference under the name mac_stubs_kdriver,
20
 
   but for convenience throughout this code, we call it "kdriver",
21
 
   which was its name when it was static.  */
22
 
short mac_stubs_kdriver = 0;            /* .Kerberos driver ref */
23
 
#define kdriver mac_stubs_kdriver
24
 
 
25
 
ParamBlockRec pb[1];
26
 
struct krbHiParmBlock khipb[1];
27
 
struct krbParmBlock klopb[1];
28
 
 
29
 
short lowcall (long cscode, krbParmBlock *klopb, short kdriver)
30
 
{
31
 
        short s;
32
 
        ParamBlockRec pb;
33
 
        
34
 
        memset (&pb, 0, sizeof(ParamBlockRec));
35
 
        *(long *)pb.cntrlParam.csParam = (long)klopb;
36
 
        pb.cntrlParam.ioCompletion = nil;
37
 
        pb.cntrlParam.ioCRefNum = kdriver;
38
 
        pb.cntrlParam.csCode = cscode;
39
 
        
40
 
        if (s = PBControl(&pb, false))
41
 
                return KFAILURE;
42
 
        if (s = pb.cntrlParam.ioResult)
43
 
                return -(s - cKrbKerberosErrBlock);     /* Restore krb err code from driver err */
44
 
 
45
 
        return KSUCCESS;
46
 
}
47
 
 
48
 
 
49
 
short hicall (long cscode, krbHiParmBlock *khipb, short kdriver)
50
 
{
51
 
        short s;
52
 
        ParamBlockRec pb;
53
 
        memset(&pb, 0, sizeof(ParamBlockRec));
54
 
        *(long *)pb.cntrlParam.csParam = (long)khipb;
55
 
        pb.cntrlParam.ioCompletion = nil;
56
 
        pb.cntrlParam.ioCRefNum = kdriver;
57
 
 
58
 
        pb.cntrlParam.csCode = cscode;
59
 
        if (s = PBControl(&pb, false))
60
 
                return KFAILURE;
61
 
        if (s = pb.cntrlParam.ioResult)
62
 
                return -(s - cKrbKerberosErrBlock);     /* Restore krb err code from driver err */
63
 
 
64
 
        return KSUCCESS;
65
 
}
66
 
 
67
 
 
68
 
int INTERFACE
69
 
krb_start_session (x)
70
 
        char *x;
71
 
{
72
 
        short s;
73
 
        
74
 
        /*
75
 
         * Open the .Kerberos driver if not already open
76
 
         */
77
 
        if (!kdriver) {
78
 
                s = OpenDriver("\p.Kerberos", &kdriver);
79
 
                if (s) {
80
 
                        return KFAILURE;        /* Improve this error code */
81
 
                }
82
 
        }
83
 
 
84
 
        return KSUCCESS;
85
 
}
86
 
 
87
 
 
88
 
int INTERFACE
89
 
krb_end_session (x)
90
 
        char *x;
91
 
{
92
 
        short s;
93
 
 
94
 
#if 0 /* This driver doesn't want to be closed.  FIXME, is this OK? */
95
 
        if (kdriver) {
96
 
                s = CloseDriver(kdriver);
97
 
                if (s)
98
 
                        return KFAILURE;
99
 
                kdriver = 0;
100
 
        }
101
 
#endif
102
 
        return KSUCCESS;
103
 
}
104
 
 
105
 
 
106
 
char * INTERFACE
107
 
krb_realmofhost (host)
108
 
        char *host;
109
 
{
110
 
        short s;
111
 
        ParamBlockRec pb;
112
 
        static char realm[REALM_SZ];
113
 
 
114
 
        memset(klopb, 0, sizeof(*klopb));
115
 
        klopb->host = host;
116
 
        klopb->uRealm = realm;
117
 
        
118
 
        /* FIXME jcm - no error handling for return value of lowcall in krb_realmofhost */
119
 
        s = lowcall (cKrbGetRealm , klopb, kdriver);
120
 
 
121
 
        return realm;
122
 
}
123
 
 
124
 
int INTERFACE
125
 
krb_get_lrealm (realm, n)
126
 
        char *realm;
127
 
        int n;
128
 
{
129
 
        short s;
130
 
        ParamBlockRec pb;
131
 
 
132
 
        if (n != 1)
133
 
                return KFAILURE;
134
 
 
135
 
        memset(klopb, 0, sizeof(*klopb));
136
 
        klopb->uRealm = realm;
137
 
 
138
 
        s = lowcall (cKrbGetLocalRealm, klopb, kdriver);
139
 
        return s;
140
 
                
141
 
}
142
 
 
143
 
 
144
 
int INTERFACE
145
 
kname_parse (name, instance, realm, fullname)
146
 
        char *name, *instance, *realm, *fullname;
147
 
{
148
 
        short s;
149
 
        ParamBlockRec pb;
150
 
 
151
 
        memset(klopb, 0, sizeof(*klopb));
152
 
        klopb->uName = name;
153
 
        klopb->uInstance = instance;
154
 
        klopb->uRealm = realm;
155
 
        klopb->fullname = fullname;
156
 
 
157
 
        s = lowcall (cKrbKnameParse, klopb, kdriver);
158
 
        return s;
159
 
}
160
 
 
161
 
const char* INTERFACE
162
 
krb_get_err_text (error_code)
163
 
        int error_code;
164
 
{
165
 
        short s;
166
 
        
167
 
        memset(klopb, 0, sizeof(*klopb));
168
 
        klopb->admin = error_code;      
169
 
        s = lowcall (cKrbGetErrText, klopb, kdriver);
170
 
        if (s != KSUCCESS)
171
 
                return "Error in get_err_text"; 
172
 
        return klopb->uName;
173
 
}
174
 
 
175
 
 
176
 
int INTERFACE
177
 
krb_get_pw_in_tkt(user,instance,realm,service,sinstance,life,password)
178
 
    char *user, *instance, *realm, *service, *sinstance;
179
 
    int life;
180
 
    char *password;
181
 
{
182
 
        short s;
183
 
        
184
 
        memset(klopb, 0, sizeof(*klopb));
185
 
        klopb->uName = user;    
186
 
        klopb->uInstance = instance;
187
 
        klopb->uRealm = realm;
188
 
        klopb->sName = service;
189
 
        klopb->sInstance = sinstance;
190
 
        klopb->admin = life;
191
 
        klopb->fullname = password;
192
 
        
193
 
        s = lowcall (cKrbGetPwInTkt, klopb, kdriver);
194
 
        return s;
195
 
}
196
 
 
197
 
 
198
 
/* FIXME:  For now, we handle the preauth version exactly the same
199
 
   as the non-preauth.   */
200
 
krb_get_pw_in_tkt_preauth(user,instance,realm,service,sinstance,life,password)
201
 
    char *user, *instance, *realm, *service, *sinstance;
202
 
    int life;
203
 
    char *password;
204
 
{
205
 
        short s;
206
 
        
207
 
        memset(klopb, 0, sizeof(*klopb));
208
 
        klopb->uName = user;    
209
 
        klopb->uInstance = instance;
210
 
        klopb->uRealm = realm;
211
 
        klopb->sName = service;
212
 
        klopb->sInstance = sinstance;
213
 
        klopb->admin = life;
214
 
        klopb->fullname = password;
215
 
        
216
 
        s = lowcall (cKrbGetPwInTkt, klopb, kdriver);
217
 
        return s;
218
 
}
219
 
 
220
 
 
221
 
 
222
 
char* INTERFACE
223
 
krb_get_default_user (void)
224
 
{
225
 
        short s;
226
 
        static char return_name[MAX_K_NAME_SZ];
227
 
        
228
 
        memset(khipb, 0, sizeof(*khipb));
229
 
        khipb->user = return_name;
230
 
        s = hicall (cKrbGetUserName, khipb, kdriver);
231
 
        if (s != KSUCCESS)
232
 
                return 0;
233
 
        return return_name;
234
 
}
235
 
 
236
 
 
237
 
int INTERFACE
238
 
krb_set_default_user (uName)
239
 
        char* uName;
240
 
{
241
 
        short s;
242
 
        
243
 
        memset(khipb, 0, sizeof(*khipb));
244
 
        khipb->user = uName;
245
 
        s = hicall (cKrbSetUserName, khipb, kdriver);
246
 
        return s;
247
 
}
248
 
 
249
 
int INTERFACE
250
 
krb_get_cred (name, instance, realm, cr)
251
 
        char *name;
252
 
        char *instance;
253
 
        char *realm;
254
 
        CREDENTIALS *cr;
255
 
{
256
 
        short s;
257
 
        
258
 
        memset(klopb, 0, sizeof(*klopb));
259
 
        
260
 
        strcpy(cr->service, name);
261
 
        strcpy(cr->instance, instance);
262
 
        strcpy(cr->realm, realm);
263
 
        
264
 
        klopb->cred = cr;
265
 
 
266
 
        s = lowcall (cKrbGetCredentials, klopb, kdriver);
267
 
        return s;
268
 
}
269
 
 
270
 
int INTERFACE
271
 
krb_save_credentials (sname, sinstance, srealm, session, 
272
 
                        lifetime, kvno,ticket, issue_date)
273
 
        char *sname;            /* service name */
274
 
        char *sinstance;        /* service instance */
275
 
        char *srealm;           /* service realm */
276
 
        C_Block session;        /* Session key */
277
 
        int lifetime;           /* Lifetime */
278
 
        int kvno;                       /* Key version number */
279
 
    KTEXT ticket;           /* The ticket itself */
280
 
        long issue_date;        /* The issue time */
281
 
        
282
 
{
283
 
        short s;
284
 
        CREDENTIALS cr;
285
 
        
286
 
        strcpy(cr.service, sname);
287
 
        strcpy(cr.instance, sinstance);
288
 
        strcpy(cr.realm, srealm);
289
 
        memcpy(cr.session, session, sizeof(C_Block));
290
 
        cr.lifetime = lifetime;
291
 
        cr.kvno = kvno;
292
 
        cr.ticket_st = *ticket;
293
 
        cr.issue_date = issue_date;
294
 
        
295
 
        memset(klopb, 0, sizeof(*klopb));
296
 
        klopb->cred = &cr;
297
 
 
298
 
        s = lowcall (cKrbAddCredentials, klopb, kdriver);
299
 
        return s;
300
 
}
301
 
 
302
 
 
303
 
int INTERFACE
304
 
krb_delete_cred (sname, sinstance, srealm)
305
 
        char *sname;
306
 
        char *sinstance;
307
 
        char *srealm;
308
 
{
309
 
        short s;
310
 
        
311
 
        memset(klopb, 0, sizeof(*klopb));
312
 
        
313
 
        klopb->sName = sname;
314
 
        klopb->sInstance = sinstance;
315
 
        klopb->sRealm = srealm;
316
 
        
317
 
        s = lowcall (cKrbDeleteCredentials, klopb, kdriver);
318
 
        return s;
319
 
}
320
 
 
321
 
int INTERFACE
322
 
dest_tkt (cachename)
323
 
        char *cachename;                /* This parameter is ignored. */
324
 
{
325
 
        short s;
326
 
        
327
 
        memset(klopb, 0, sizeof(*klopb));
328
 
        s = lowcall (cKrbDeleteAllSessions, klopb, kdriver);
329
 
        return s;
330
 
}
331
 
 
332
 
/* 
333
 
 *      returns service name, service instance and realm of the nth credential. 
334
 
 *  credential numbering is 1 based.
335
 
 */
336
 
 
337
 
int INTERFACE
338
 
krb_get_nth_cred (sname, sinstance, srealm, n)
339
 
        char *sname;
340
 
        char *sinstance;
341
 
        char *srealm;
342
 
        int n;
343
 
{
344
 
        short s;
345
 
        
346
 
        memset(klopb, 0, sizeof(*klopb));
347
 
        
348
 
        klopb->sName = sname;
349
 
        klopb->sInstance = sinstance;
350
 
        klopb->sRealm = srealm;
351
 
        klopb->itemNumber = &n;
352
 
        
353
 
        s = lowcall (cKrbGetNthCredentials, klopb, kdriver);
354
 
        return s;
355
 
}
356
 
 
357
 
/*
358
 
 * Return the number of credentials in the current credential cache (ticket cache).
359
 
 * On error, returns -1. 
360
 
 */
361
 
int INTERFACE
362
 
krb_get_num_cred ()
363
 
{
364
 
        int s;
365
 
        int n;
366
 
        
367
 
        memset(klopb, 0, sizeof(*klopb));
368
 
        klopb->itemNumber = &n;
369
 
        
370
 
        s = lowcall (cKrbGetNumCredentials, klopb, kdriver);
371
 
        if (s) 
372
 
                return -1;
373
 
        return *(klopb->itemNumber);
374
 
}
375
 
 
376
 
 
377
 
 
378
 
/* GetNthRealmMap
379
 
   yields the Nth mapping of a net or host to a Kerberos realm 
380
 
          -> itemNumber         which mapping, traditionally the first
381
 
          -> host                       host or net
382
 
          -> uRealm             pointer to buffer that will receive realm name
383
 
*/
384
 
 
385
 
OSErr INTERFACE
386
 
GetNthRealmMap(n, netorhost, realm)
387
 
        int n;
388
 
        char *netorhost;
389
 
        char *realm;
390
 
{
391
 
        int s;
392
 
        memset(klopb, 0, sizeof(*klopb));
393
 
        klopb->itemNumber = &n;
394
 
        klopb->host = netorhost;
395
 
        klopb->uRealm = realm;
396
 
        
397
 
        s = lowcall (cKrbGetNthRealmMap, klopb, kdriver);
398
 
        return s;
399
 
}
400
 
 
401
 
/* GetNthServerMap
402
 
   yields Nth realm-server mapping
403
 
   -> itemNumber                which mapping should be returned
404
 
   -> uRealm                    pointer to buffer that will receive realm name  
405
 
   -> host                              pointer to buffer that will receive server name
406
 
   -> admin                             pointer to admin flag
407
 
 */
408
 
        
409
 
OSErr   INTERFACE
410
 
GetNthServerMap(n, realm, server, admin)        
411
 
    int n;
412
 
    char *realm;
413
 
    char *server; 
414
 
    int *admin;
415
 
{
416
 
        int s;
417
 
        memset(klopb, 0, sizeof(*klopb));
418
 
        klopb->itemNumber = &n;
419
 
        klopb->uRealm = realm;
420
 
        klopb->host = server;
421
 
        klopb->adminReturn = admin;
422
 
 
423
 
        s = lowcall (cKrbGetNthServerMap, klopb, kdriver);
424
 
        return s;
425
 
}
426
 
 
427
 
 
428
 
 
429
 
/* krb_get_ticket_for_service
430
 
 * Gets a ticket and returns it to application in buf
431
 
          -> service            Formal Kerberos name of service
432
 
          -> buf                Buffer to receive ticket
433
 
          -> checksum           checksum for this service
434
 
         <-> buflen             length of ticket buffer (must be at least
435
 
                                        1258 bytes)
436
 
         <-  sessionKey         for internal use
437
 
         <-  schedule           for internal use
438
 
 
439
 
 * Result is:
440
 
 *   GC_NOTKT           if there is no matching TGT in the cache
441
 
 *   MK_AP_TGTEXP       if the matching TGT is expired
442
 
 * Other errors possible.  These could cause a dialogue with the user
443
 
 * to get a new TGT.
444
 
 */ 
445
 
 
446
 
int INTERFACE
447
 
krb_get_ticket_for_service (serviceName, buf, buflen, checksum, sessionKey,
448
 
                schedule, version, includeVersion)
449
 
        char *serviceName;
450
 
        char *buf;
451
 
        unsigned KRB4_32 *buflen;
452
 
        int checksum;
453
 
        des_cblock sessionKey;
454
 
        Key_schedule schedule;
455
 
        char *version;
456
 
        int includeVersion;
457
 
{
458
 
        short s;
459
 
 
460
 
        if (includeVersion)
461
 
                return KFAILURE;                /* Not implmented in the kclient driver iface */
462
 
        
463
 
        memset(khipb, 0, sizeof(*khipb));
464
 
        khipb->service = serviceName;
465
 
        khipb->buf = buf;
466
 
        khipb->buflen = *buflen;
467
 
        khipb->checksum = checksum;
468
 
 
469
 
        s = hicall (cKrbGetTicketForService, khipb, kdriver);
470
 
        /* These are ARRAYS in the hiparmblock, for some reason! */
471
 
        memcpy (sessionKey, khipb->sessionKey, sizeof (khipb[0].sessionKey));
472
 
        memcpy (schedule,   khipb->schedule,   sizeof (khipb[0].schedule));
473
 
        *buflen = khipb->buflen;
474
 
        return s;
475
 
}
476
 
 
477
 
 
478
 
/*      krb_get_tf_fullname -- return name, instance and realm of the
479
 
        principal in the current ticket file. The ticket file name is not 
480
 
        currently used for anything since there is only one credentials 
481
 
        cache/ticket file
482
 
*/
483
 
 
484
 
int INTERFACE
485
 
krb_get_tf_fullname (tktfile, name, instance, realm)
486
 
  char *tktfile;
487
 
  char *name;
488
 
  char *instance;
489
 
  char *realm;
490
 
 
491
 
{
492
 
        short s;
493
 
        memset (klopb, 0, sizeof(*klopb));
494
 
        klopb->fullname = tktfile;
495
 
        klopb->uName = name;
496
 
        klopb->uInstance = instance;
497
 
        klopb->uRealm = realm;
498
 
        
499
 
        s = lowcall (cKrbGetTfFullname, klopb, kdriver);
500
 
        return s;
501
 
}
502
 
 
503
 
 
504
 
 
505
 
#if 0
506
 
        xbzero(khipb, sizeof(krbHiParmBlock));
507
 
        khipb->service = (char *)cannon;
508
 
        khipb->buf = (char *)buf;                               /* where to build it */
509
 
        khipb->checksum = 0;
510
 
        khipb->buflen = sizeof(buf);
511
 
        if (s = hicall(cKrbGetTicketForService, khipb, kdriver))
512
 
                return s;
513
 
        xbcopy(khipb->sessionKey, sessionKey, sizeof(sessionKey));      /* save the session key */
514
 
        /*
515
 
         * cKrbGetTicketForService put a longword buffer length into the buffer
516
 
         * which we don't want, so we ignore it.
517
 
     * Make room for first 3 bytes which preceed the auth data.
518
 
         */
519
 
        cp = &buf[4-3];                                         /* skip long, make room for 3 bytes */
520
 
        cp[0] = tp[0];                                          /* copy type and modifier */
521
 
        cp[1] = tp[1];
522
 
        cp[2] = KRB_AUTH;                                       /* suboption command */
523
 
        len = khipb->buflen - sizeof(long) + 3; /* data - 4 + 3 */
524
 
 
525
 
#endif /* 0 */