← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/kim/agent/mac/KIMUtilities.m

  • 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/kim/agent/mac/KIMUtilities.m
 
1
/*
 
2
 * Copyright 2008 Massachusetts Institute of Technology.
 
3
 * All Rights Reserved.
 
4
 *
 
5
 * Export of this software from the United States of America may
 
6
 * require a specific license from the United States Government.
 
7
 * It is the responsibility of any person or organization contemplating
 
8
 * export to obtain such a license before exporting.
 
9
 * 
 
10
 * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
 
11
 * distribute this software and its documentation for any purpose and
 
12
 * without fee is hereby granted, provided that the above copyright
 
13
 * notice appear in all copies and that both that copyright notice and
 
14
 * this permission notice appear in supporting documentation, and that
 
15
 * the name of M.I.T. not be used in advertising or publicity pertaining
 
16
 * to distribution of the software without specific, written prior
 
17
 * permission.  Furthermore if you modify this software you must label
 
18
 * your software as modified software and not distribute it in such a
 
19
 * fashion that it might be confused with the original M.I.T. software.
 
20
 * M.I.T. makes no representations about the suitability of
 
21
 * this software for any purpose.  It is provided "as is" without express
 
22
 * or implied warranty.
 
23
 */
 
24
 
 
25
#import "KIMUtilities.h"
 
26
 
 
27
@implementation KIMUtilities
 
28
 
 
29
+ (NSString *) stringForLastKIMError: (kim_error) in_err
 
30
{
 
31
    kim_error err = KIM_NO_ERROR;
 
32
    kim_string string = NULL;
 
33
    NSString *result = nil;
 
34
    
 
35
    err = kim_string_create_for_last_error(&string, in_err);
 
36
    if (!err) {
 
37
        result = [NSString stringWithUTF8String:string];
 
38
    }
 
39
    kim_string_free(&string);
 
40
    
 
41
    return result;
 
42
}
 
43
 
 
44
+ (BOOL) validatePrincipalWithName: (NSString *) name
 
45
                             realm: (NSString *) realm
 
46
{
 
47
    kim_error err = KIM_NO_ERROR;
 
48
    NSString *identityString = nil;
 
49
    
 
50
    if (!name || !realm || [name length] == 0) {
 
51
        err = KIM_BAD_PRINCIPAL_STRING_ERR;
 
52
    }
 
53
    if (!err) {
 
54
        identityString = [[NSString alloc] initWithFormat:@"%@@%@", name, realm];
 
55
        err = [KIMUtilities validateIdentity:identityString];
 
56
        [identityString release];
 
57
    }
 
58
    
 
59
    return (err == KIM_NO_ERROR);
 
60
}
 
61
 
 
62
+ (BOOL) validateIdentity: (NSString *) identityString
 
63
{
 
64
    kim_error err = KIM_NO_ERROR;
 
65
    kim_identity identity = NULL;
 
66
    
 
67
    if (!identityString || [identityString length] <= 1) {
 
68
        err = KIM_BAD_PRINCIPAL_STRING_ERR;
 
69
    }
 
70
    if (!err) {
 
71
        err = kim_identity_create_from_string(&identity, [identityString UTF8String]);
 
72
    }
 
73
    if (!identity) {
 
74
        err = KIM_BAD_PRINCIPAL_STRING_ERR;
 
75
    }
 
76
    kim_identity_free(&identity);
 
77
    
 
78
    return (err == KIM_NO_ERROR);
 
79
}
 
80
 
 
81
+ (NSString *) expandedIdentity: (NSString *) identityString
 
82
{
 
83
    NSString *result = nil;
 
84
    kim_error err = KIM_NO_ERROR;
 
85
    kim_identity identity = NULL;
 
86
    kim_string validated_string = NULL;
 
87
    
 
88
    // convert to how it will actually be
 
89
    // e.g. foo becomes foo@ATHENA.MIT.EDU
 
90
    // for the purpose of matching to a favorite
 
91
    if (!identityString) {
 
92
        err = KIM_BAD_PRINCIPAL_STRING_ERR;
 
93
    }
 
94
    if (!err) {
 
95
        err = kim_identity_create_from_string(&identity, [identityString UTF8String]);
 
96
    }
 
97
    if (!err && identity) {
 
98
        err = kim_identity_get_display_string(identity, &validated_string);
 
99
    }
 
100
    if (!err && validated_string) {
 
101
        result = [NSString stringWithUTF8String:validated_string];
 
102
    }
 
103
    kim_identity_free(&identity);
 
104
    kim_string_free(&validated_string);
 
105
    
 
106
    return result;
 
107
}
 
108
 
 
109
+ (NSDictionary *) dictionaryForKimOptions: (kim_options) options
 
110
{
 
111
    kim_error err = KIM_NO_ERROR;
 
112
    kim_preferences prefs = NULL;
 
113
    NSMutableDictionary *newDict = [NSMutableDictionary dictionaryWithCapacity:8];
 
114
    kim_boolean addressless = FALSE;
 
115
    kim_boolean forwardable = FALSE;
 
116
    kim_boolean proxiable = FALSE;
 
117
    kim_boolean renewable = FALSE;
 
118
    kim_lifetime valid_lifetime = 0;
 
119
    kim_lifetime renewal_lifetime = 0;
 
120
    kim_string service_name = NULL;
 
121
    kim_time start_time = 0;
 
122
    
 
123
    if (options == KIM_OPTIONS_DEFAULT) {
 
124
        [newDict setObject:[NSNumber numberWithBool:YES]
 
125
                    forKey:@"usesDefaultTicketOptions"];
 
126
        err = kim_preferences_create(&prefs);
 
127
        if (!err) {
 
128
            err = kim_preferences_get_options(prefs, &options);
 
129
        }
 
130
    }
 
131
    
 
132
    if (!err) {
 
133
        err = kim_options_get_addressless(options, &addressless);
 
134
    }
 
135
    if (!err) {
 
136
        [newDict setValue:[NSNumber numberWithBool:addressless] 
 
137
                                            forKey:@"addressless"];
 
138
    }
 
139
    if (!err) {
 
140
        err = kim_options_get_forwardable(options, &forwardable);
 
141
    }
 
142
    if (!err) {
 
143
        [newDict setValue:[NSNumber numberWithBool:forwardable] 
 
144
                                            forKey:@"forwardable"];
 
145
    }
 
146
    if (!err) {
 
147
        err = kim_options_get_proxiable(options, &proxiable);
 
148
    }
 
149
    if (!err) {
 
150
        [newDict setValue:[NSNumber numberWithBool:proxiable] 
 
151
                                            forKey:@"proxiable"];
 
152
    }
 
153
    if (!err) {
 
154
        err = kim_options_get_renewable(options, &renewable);
 
155
    }
 
156
    if (!err) {
 
157
        [newDict setValue:[NSNumber numberWithBool:renewable] 
 
158
                                            forKey:@"renewable"];
 
159
    }
 
160
    if (!err) {
 
161
        err = kim_options_get_lifetime(options, &valid_lifetime);
 
162
    }
 
163
    if (!err) {
 
164
        [newDict setValue:[NSNumber numberWithInteger:valid_lifetime] 
 
165
                                               forKey:@"valid_lifetime"];
 
166
    }
 
167
    if (!err) {
 
168
        err = kim_options_get_renewal_lifetime(options, &renewal_lifetime);
 
169
    }
 
170
    if (!err) {
 
171
        [newDict setValue:[NSNumber numberWithInteger:renewal_lifetime] 
 
172
                                               forKey:@"renewal_lifetime"];
 
173
    }
 
174
    if (!err) {
 
175
        err = kim_options_get_service_name(options, &service_name);
 
176
    }
 
177
    if (!err) {
 
178
        [newDict setValue:(service_name) ? 
 
179
         [NSString stringWithUTF8String:service_name] : @""
 
180
                   forKey:@"service_name"];
 
181
    }
 
182
    if (!err) {
 
183
        err = kim_options_get_start_time(options, &start_time);
 
184
    }
 
185
    if (!err) {
 
186
        [newDict setValue:[NSNumber numberWithInteger:start_time] 
 
187
                   forKey:@"start_time"];
 
188
    }
 
189
 
 
190
    // only free options if it was allocated by this method
 
191
    if (prefs) {
 
192
        kim_options_free(&options);
 
193
        kim_preferences_free(&prefs);
 
194
    }
 
195
 
 
196
    return newDict;
 
197
}
 
198
 
 
199
+ (kim_options) kimOptionsForDictionary: (NSDictionary *) aDict
 
200
{
 
201
    kim_error err = KIM_NO_ERROR;
 
202
    kim_options options = NULL;
 
203
    kim_boolean addressless;
 
204
    kim_boolean forwardable;
 
205
    kim_boolean proxiable;
 
206
    kim_boolean renewable;
 
207
    kim_lifetime valid_lifetime;
 
208
    kim_lifetime renewal_lifetime;
 
209
    kim_string service_name;
 
210
    kim_time start_time;
 
211
 
 
212
    if (!aDict || [[aDict objectForKey:@"usesDefaultTicketOptions"] boolValue]) {
 
213
        return KIM_OPTIONS_DEFAULT;
 
214
    }
 
215
    
 
216
    addressless = [[aDict valueForKey:@"addressless"] boolValue];
 
217
    forwardable = [[aDict valueForKey:@"forwardable"] boolValue];
 
218
    proxiable = [[aDict valueForKey:@"proxiable"] boolValue];
 
219
    renewable = [[aDict valueForKey:@"renewable"] boolValue];
 
220
    valid_lifetime = [[aDict valueForKey:@"valid_lifetime"] integerValue];
 
221
    renewal_lifetime = [[aDict valueForKey:@"renewal_lifetime"] integerValue];
 
222
    service_name = ([[aDict valueForKey:@"service_name"] length] > 0) ?
 
223
    [[aDict valueForKey:@"service_name"] UTF8String] : NULL;
 
224
    start_time = [[aDict valueForKey:@"start_time"] integerValue];
 
225
    
 
226
    if (!err) {
 
227
        err = kim_options_create (&options);
 
228
    }
 
229
    if (!err) {
 
230
        err = kim_options_set_addressless(options, addressless);
 
231
    }
 
232
    if (!err) {
 
233
        err = kim_options_set_forwardable(options, forwardable);
 
234
    }
 
235
    if (!err) {
 
236
        err = kim_options_set_proxiable(options, proxiable);
 
237
    }
 
238
    if (!err) {
 
239
        err = kim_options_set_renewable(options, renewable);
 
240
    }
 
241
    if (!err) {
 
242
        err = kim_options_set_lifetime(options, valid_lifetime);
 
243
    }
 
244
    if (!err) {
 
245
        err = kim_options_set_renewal_lifetime(options, renewal_lifetime);
 
246
    }
 
247
    if (!err) {
 
248
        err = kim_options_set_service_name(options, service_name);
 
249
    }
 
250
    if (!err) {
 
251
        err = kim_options_set_start_time(options, start_time);
 
252
    }
 
253
    
 
254
    return options;
 
255
}
 
256
 
 
257
+ (NSDictionary *) dictionaryForKimSelectionHints: (kim_selection_hints) hints
 
258
{
 
259
    kim_error err = KIM_NO_ERROR;
 
260
 
 
261
    NSMutableDictionary *newDict = [NSMutableDictionary dictionaryWithCapacity:20];
 
262
    
 
263
    kim_string explanation             = NULL;
 
264
    kim_options options                = NULL;
 
265
    kim_string service_identity        = NULL;
 
266
    kim_string client_realm            = NULL;
 
267
    kim_string user                    = NULL;
 
268
    kim_string service_realm           = NULL;
 
269
    kim_string service                 = NULL;
 
270
    kim_string server                  = NULL;
 
271
 
 
272
    if (!err) {
 
273
        err = kim_selection_hints_get_explanation(hints, &explanation);
 
274
        [newDict setValue:(explanation) ? [NSString stringWithUTF8String:explanation] : @"" 
 
275
                   forKey:@"explanation"];
 
276
    }
 
277
    if (!err) {
 
278
        err = kim_selection_hints_get_options(hints, &options);
 
279
        [newDict setValue:[KIMUtilities dictionaryForKimOptions:options]
 
280
                   forKey:@"options"];
 
281
    }
 
282
    if (!err) {
 
283
        err = kim_selection_hints_get_hint(hints, kim_hint_key_client_realm, &client_realm);
 
284
        [newDict setValue:(client_realm) ? [NSString stringWithUTF8String:client_realm] : @"" 
 
285
                    forKey:@"client_realm"];
 
286
    }
 
287
    if (!err) {
 
288
        err = kim_selection_hints_get_hint(hints, kim_hint_key_user, &user);
 
289
        [newDict setValue:(user) ? [NSString stringWithUTF8String:user] : @"" 
 
290
                   forKey:@"user"];
 
291
    }
 
292
    if (!err) {
 
293
        err = kim_selection_hints_get_hint(hints, kim_hint_key_service_realm, &service_realm);
 
294
        [newDict setValue:(service_realm) ? [NSString stringWithUTF8String:service_realm] : @"" 
 
295
                   forKey:@"service_realm"];
 
296
    }
 
297
    if (!err) {
 
298
        err = kim_selection_hints_get_hint(hints, kim_hint_key_service, &service);
 
299
        [newDict setValue:(service) ? [NSString stringWithUTF8String:service] : @"" 
 
300
                   forKey:@"service"];
 
301
    }
 
302
    if (!err) {
 
303
        err = kim_selection_hints_get_hint(hints, kim_hint_key_server, &server);
 
304
        [newDict setValue:(server) ? [NSString stringWithUTF8String:server] : @"" 
 
305
                   forKey:@"server"];
 
306
    }
 
307
    if (!err) {
 
308
        err = kim_selection_hints_get_hint(hints, kim_hint_key_service_identity, &service_identity);
 
309
        [newDict setValue:(service_identity) ? [NSString stringWithUTF8String:service_identity] : @"" 
 
310
                   forKey:@"service_identity"];
 
311
    }
 
312
    
 
313
    return newDict;
 
314
}
 
315
 
 
316
+ (NSUInteger)minValidLifetime
 
317
{
 
318
    kim_error err = KIM_NO_ERROR;
 
319
    kim_preferences prefs = NULL;
 
320
    kim_lifetime value = 0;
 
321
    
 
322
    err = kim_preferences_create(&prefs);
 
323
    
 
324
    if (!err) {
 
325
        kim_preferences_get_minimum_lifetime(prefs, &value);
 
326
    }
 
327
    
 
328
    return (NSUInteger) value;
 
329
}
 
330
 
 
331
+ (NSUInteger)maxValidLifetime
 
332
{
 
333
    kim_error err = KIM_NO_ERROR;
 
334
    kim_preferences prefs = NULL;
 
335
    kim_lifetime value = 0;
 
336
    
 
337
    err = kim_preferences_create(&prefs);
 
338
    
 
339
    if (!err) {
 
340
        kim_preferences_get_maximum_lifetime(prefs, &value);
 
341
    }
 
342
    
 
343
    return (NSUInteger) value;
 
344
}
 
345
 
 
346
+ (NSUInteger)minRenewableLifetime
 
347
{
 
348
    kim_error err = KIM_NO_ERROR;
 
349
    kim_preferences prefs = NULL;
 
350
    kim_lifetime value = 0;
 
351
    
 
352
    err = kim_preferences_create(&prefs);
 
353
    
 
354
    if (!err) {
 
355
        kim_preferences_get_minimum_renewal_lifetime(prefs, &value);
 
356
    }
 
357
    
 
358
    return (NSUInteger) value;
 
359
}
 
360
 
 
361
+ (NSUInteger)maxRenewableLifetime
 
362
{
 
363
    kim_error err = KIM_NO_ERROR;
 
364
    kim_preferences prefs = NULL;
 
365
    kim_lifetime value = 0;
 
366
    
 
367
    err = kim_preferences_create(&prefs);
 
368
    
 
369
    if (!err) {
 
370
        kim_preferences_get_maximum_renewal_lifetime(prefs, &value);
 
371
    }
 
372
    
 
373
    return (NSUInteger) value;
 
374
}
 
375
 
 
376
@end