rxkad: Update ticket5 from heimdal
[openafs.git] / src / rxkad / v5gen.h
1 /* Generated from ./krb5.asn1 */
2 /* Do not edit */
3
4 #ifndef __krb5_asn1_h__
5 #define __krb5_asn1_h__
6
7 #include <stddef.h>
8 #include <time.h>
9
10 #ifndef __asn1_common_definitions__
11 #define __asn1_common_definitions__
12
13 #ifndef __HEIM_BASE_DATA__
14 #define __HEIM_BASE_DATA__ 1
15 struct heim_base_data {
16     size_t length;
17     void *data;
18 };
19 typedef struct heim_base_data heim_octet_string;
20 #endif
21
22 typedef struct heim_integer {
23   size_t length;
24   void *data;
25   int negative;
26 } heim_integer;
27
28 typedef char *heim_general_string;
29
30 typedef char *heim_utf8_string;
31
32 typedef struct heim_base_data heim_printable_string;
33
34 typedef struct heim_base_data heim_ia5_string;
35
36 typedef struct heim_bmp_string {
37   size_t length;
38   afs_uint16 *data;
39 } heim_bmp_string;
40
41 typedef struct heim_universal_string {
42   size_t length;
43   afs_uint32 *data;
44 } heim_universal_string;
45
46 typedef char *heim_visible_string;
47
48 typedef struct heim_oid {
49   size_t length;
50   unsigned *components;
51 } heim_oid;
52
53 typedef struct heim_bit_string {
54   size_t length;
55   void *data;
56 } heim_bit_string;
57
58 typedef struct heim_base_data heim_any;
59 typedef struct heim_base_data heim_any_set;
60
61 #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R)                  \
62   do {                                                         \
63     (BL) = length_##T((S));                                    \
64     (B) = malloc((BL));                                        \
65     if((B) == NULL) {                                          \
66       (R) = ENOMEM;                                            \
67     } else {                                                   \
68       (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \
69                        (S), (L));                              \
70       if((R) != 0) {                                           \
71         free((B));                                             \
72         (B) = NULL;                                            \
73       }                                                        \
74     }                                                          \
75   } while (0)
76
77 #ifdef _WIN32
78 #ifndef ASN1_LIB
79 #define ASN1EXP  __declspec(dllimport)
80 #else
81 #define ASN1EXP
82 #endif
83 #define ASN1CALL __stdcall
84 #else
85 #define ASN1EXP
86 #define ASN1CALL
87 #endif
88
89 #endif
90
91 /*
92 NAME-TYPE ::= INTEGER {
93   KRB5_NT_UNKNOWN(0),
94   KRB5_NT_PRINCIPAL(1),
95   KRB5_NT_SRV_INST(2),
96   KRB5_NT_SRV_HST(3),
97   KRB5_NT_SRV_XHST(4),
98   KRB5_NT_UID(5),
99   KRB5_NT_X500_PRINCIPAL(6),
100   KRB5_NT_SMTP_NAME(7),
101   KRB5_NT_ENTERPRISE_PRINCIPAL(10),
102   KRB5_NT_WELLKNOWN(11),
103   KRB5_NT_SRV_HST_DOMAIN(12),
104   KRB5_NT_ENT_PRINCIPAL_AND_ID(-130),
105   KRB5_NT_MS_PRINCIPAL(-128),
106   KRB5_NT_MS_PRINCIPAL_AND_ID(-129),
107   KRB5_NT_NTLM(-1200),
108   KRB5_NT_X509_GENERAL_NAME(-1201),
109   KRB5_NT_GSS_HOSTBASED_SERVICE(-1202),
110   KRB5_NT_CACHE_UUID(-1203),
111   KRB5_NT_SRV_HST_NEEDS_CANON(-195894762)
112 }
113 */
114
115 typedef enum NAME_TYPE {
116   KRB5_NT_UNKNOWN = 0,
117   KRB5_NT_PRINCIPAL = 1,
118   KRB5_NT_SRV_INST = 2,
119   KRB5_NT_SRV_HST = 3,
120   KRB5_NT_SRV_XHST = 4,
121   KRB5_NT_UID = 5,
122   KRB5_NT_X500_PRINCIPAL = 6,
123   KRB5_NT_SMTP_NAME = 7,
124   KRB5_NT_ENTERPRISE_PRINCIPAL = 10,
125   KRB5_NT_WELLKNOWN = 11,
126   KRB5_NT_SRV_HST_DOMAIN = 12,
127   KRB5_NT_ENT_PRINCIPAL_AND_ID = -130,
128   KRB5_NT_MS_PRINCIPAL = -128,
129   KRB5_NT_MS_PRINCIPAL_AND_ID = -129,
130   KRB5_NT_NTLM = -1200,
131   KRB5_NT_X509_GENERAL_NAME = -1201,
132   KRB5_NT_GSS_HOSTBASED_SERVICE = -1202,
133   KRB5_NT_CACHE_UUID = -1203,
134   KRB5_NT_SRV_HST_NEEDS_CANON = -195894762
135 } NAME_TYPE;
136
137 ASN1EXP int    ASN1CALL decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t *);
138 ASN1EXP int    ASN1CALL encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t *);
139 ASN1EXP size_t ASN1CALL length_NAME_TYPE(const NAME_TYPE *);
140 ASN1EXP int    ASN1CALL copy_NAME_TYPE  (const NAME_TYPE *, NAME_TYPE *);
141 ASN1EXP void   ASN1CALL free_NAME_TYPE  (NAME_TYPE *);
142
143
144 /*
145 MESSAGE-TYPE ::= INTEGER {
146   krb_as_req(10),
147   krb_as_rep(11),
148   krb_tgs_req(12),
149   krb_tgs_rep(13),
150   krb_ap_req(14),
151   krb_ap_rep(15),
152   krb_safe(20),
153   krb_priv(21),
154   krb_cred(22),
155   krb_error(30)
156 }
157 */
158
159 typedef enum MESSAGE_TYPE {
160   krb_as_req = 10,
161   krb_as_rep = 11,
162   krb_tgs_req = 12,
163   krb_tgs_rep = 13,
164   krb_ap_req = 14,
165   krb_ap_rep = 15,
166   krb_safe = 20,
167   krb_priv = 21,
168   krb_cred = 22,
169   krb_error = 30
170 } MESSAGE_TYPE;
171
172 /*
173 PADATA-TYPE ::= INTEGER {
174   KRB5_PADATA_NONE(0),
175   KRB5_PADATA_TGS_REQ(1),
176   KRB5_PADATA_AP_REQ(1),
177   KRB5_PADATA_ENC_TIMESTAMP(2),
178   KRB5_PADATA_PW_SALT(3),
179   KRB5_PADATA_ENC_UNIX_TIME(5),
180   KRB5_PADATA_SANDIA_SECUREID(6),
181   KRB5_PADATA_SESAME(7),
182   KRB5_PADATA_OSF_DCE(8),
183   KRB5_PADATA_CYBERSAFE_SECUREID(9),
184   KRB5_PADATA_AFS3_SALT(10),
185   KRB5_PADATA_ETYPE_INFO(11),
186   KRB5_PADATA_SAM_CHALLENGE(12),
187   KRB5_PADATA_SAM_RESPONSE(13),
188   KRB5_PADATA_PK_AS_REQ_19(14),
189   KRB5_PADATA_PK_AS_REP_19(15),
190   KRB5_PADATA_PK_AS_REQ_WIN(15),
191   KRB5_PADATA_PK_AS_REQ(16),
192   KRB5_PADATA_PK_AS_REP(17),
193   KRB5_PADATA_PA_PK_OCSP_RESPONSE(18),
194   KRB5_PADATA_ETYPE_INFO2(19),
195   KRB5_PADATA_USE_SPECIFIED_KVNO(20),
196   KRB5_PADATA_SVR_REFERRAL_INFO(20),
197   KRB5_PADATA_SAM_REDIRECT(21),
198   KRB5_PADATA_GET_FROM_TYPED_DATA(22),
199   KRB5_PADATA_SAM_ETYPE_INFO(23),
200   KRB5_PADATA_SERVER_REFERRAL(25),
201   KRB5_PADATA_ALT_PRINC(24),
202   KRB5_PADATA_SAM_CHALLENGE2(30),
203   KRB5_PADATA_SAM_RESPONSE2(31),
204   KRB5_PA_EXTRA_TGT(41),
205   KRB5_PADATA_FX_FAST_ARMOR(71),
206   KRB5_PADATA_TD_KRB_PRINCIPAL(102),
207   KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS(104),
208   KRB5_PADATA_PK_TD_CERTIFICATE_INDEX(105),
209   KRB5_PADATA_TD_APP_DEFINED_ERROR(106),
210   KRB5_PADATA_TD_REQ_NONCE(107),
211   KRB5_PADATA_TD_REQ_SEQ(108),
212   KRB5_PADATA_PA_PAC_REQUEST(128),
213   KRB5_PADATA_FOR_USER(129),
214   KRB5_PADATA_FOR_X509_USER(130),
215   KRB5_PADATA_FOR_CHECK_DUPS(131),
216   KRB5_PADATA_AS_CHECKSUM(132),
217   KRB5_PADATA_PK_AS_09_BINDING(132),
218   KRB5_PADATA_FX_COOKIE(133),
219   KRB5_PADATA_AUTHENTICATION_SET(134),
220   KRB5_PADATA_AUTH_SET_SELECTED(135),
221   KRB5_PADATA_FX_FAST(136),
222   KRB5_PADATA_FX_ERROR(137),
223   KRB5_PADATA_ENCRYPTED_CHALLENGE(138),
224   KRB5_PADATA_OTP_CHALLENGE(141),
225   KRB5_PADATA_OTP_REQUEST(142),
226   KBB5_PADATA_OTP_CONFIRM(143),
227   KRB5_PADATA_OTP_PIN_CHANGE(144),
228   KRB5_PADATA_EPAK_AS_REQ(145),
229   KRB5_PADATA_EPAK_AS_REP(146),
230   KRB5_PADATA_PKINIT_KX(147),
231   KRB5_PADATA_PKU2U_NAME(148),
232   KRB5_PADATA_REQ_ENC_PA_REP(149),
233   KRB5_PADATA_SUPPORTED_ETYPES(165)
234 }
235 */
236
237 typedef enum PADATA_TYPE {
238   KRB5_PADATA_NONE = 0,
239   KRB5_PADATA_TGS_REQ = 1,
240   KRB5_PADATA_AP_REQ = 1,
241   KRB5_PADATA_ENC_TIMESTAMP = 2,
242   KRB5_PADATA_PW_SALT = 3,
243   KRB5_PADATA_ENC_UNIX_TIME = 5,
244   KRB5_PADATA_SANDIA_SECUREID = 6,
245   KRB5_PADATA_SESAME = 7,
246   KRB5_PADATA_OSF_DCE = 8,
247   KRB5_PADATA_CYBERSAFE_SECUREID = 9,
248   KRB5_PADATA_AFS3_SALT = 10,
249   KRB5_PADATA_ETYPE_INFO = 11,
250   KRB5_PADATA_SAM_CHALLENGE = 12,
251   KRB5_PADATA_SAM_RESPONSE = 13,
252   KRB5_PADATA_PK_AS_REQ_19 = 14,
253   KRB5_PADATA_PK_AS_REP_19 = 15,
254   KRB5_PADATA_PK_AS_REQ_WIN = 15,
255   KRB5_PADATA_PK_AS_REQ = 16,
256   KRB5_PADATA_PK_AS_REP = 17,
257   KRB5_PADATA_PA_PK_OCSP_RESPONSE = 18,
258   KRB5_PADATA_ETYPE_INFO2 = 19,
259   KRB5_PADATA_USE_SPECIFIED_KVNO = 20,
260   KRB5_PADATA_SVR_REFERRAL_INFO = 20,
261   KRB5_PADATA_SAM_REDIRECT = 21,
262   KRB5_PADATA_GET_FROM_TYPED_DATA = 22,
263   KRB5_PADATA_SAM_ETYPE_INFO = 23,
264   KRB5_PADATA_SERVER_REFERRAL = 25,
265   KRB5_PADATA_ALT_PRINC = 24,
266   KRB5_PADATA_SAM_CHALLENGE2 = 30,
267   KRB5_PADATA_SAM_RESPONSE2 = 31,
268   KRB5_PA_EXTRA_TGT = 41,
269   KRB5_PADATA_FX_FAST_ARMOR = 71,
270   KRB5_PADATA_TD_KRB_PRINCIPAL = 102,
271   KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS = 104,
272   KRB5_PADATA_PK_TD_CERTIFICATE_INDEX = 105,
273   KRB5_PADATA_TD_APP_DEFINED_ERROR = 106,
274   KRB5_PADATA_TD_REQ_NONCE = 107,
275   KRB5_PADATA_TD_REQ_SEQ = 108,
276   KRB5_PADATA_PA_PAC_REQUEST = 128,
277   KRB5_PADATA_FOR_USER = 129,
278   KRB5_PADATA_FOR_X509_USER = 130,
279   KRB5_PADATA_FOR_CHECK_DUPS = 131,
280   KRB5_PADATA_AS_CHECKSUM = 132,
281   KRB5_PADATA_PK_AS_09_BINDING = 132,
282   KRB5_PADATA_FX_COOKIE = 133,
283   KRB5_PADATA_AUTHENTICATION_SET = 134,
284   KRB5_PADATA_AUTH_SET_SELECTED = 135,
285   KRB5_PADATA_FX_FAST = 136,
286   KRB5_PADATA_FX_ERROR = 137,
287   KRB5_PADATA_ENCRYPTED_CHALLENGE = 138,
288   KRB5_PADATA_OTP_CHALLENGE = 141,
289   KRB5_PADATA_OTP_REQUEST = 142,
290   KBB5_PADATA_OTP_CONFIRM = 143,
291   KRB5_PADATA_OTP_PIN_CHANGE = 144,
292   KRB5_PADATA_EPAK_AS_REQ = 145,
293   KRB5_PADATA_EPAK_AS_REP = 146,
294   KRB5_PADATA_PKINIT_KX = 147,
295   KRB5_PADATA_PKU2U_NAME = 148,
296   KRB5_PADATA_REQ_ENC_PA_REP = 149,
297   KRB5_PADATA_SUPPORTED_ETYPES = 165
298 } PADATA_TYPE;
299
300 ASN1EXP int    ASN1CALL decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *, size_t *);
301 ASN1EXP int    ASN1CALL encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *, size_t *);
302 ASN1EXP size_t ASN1CALL length_PADATA_TYPE(const PADATA_TYPE *);
303 ASN1EXP int    ASN1CALL copy_PADATA_TYPE  (const PADATA_TYPE *, PADATA_TYPE *);
304 ASN1EXP void   ASN1CALL free_PADATA_TYPE  (PADATA_TYPE *);
305
306
307 /*
308 AUTHDATA-TYPE ::= INTEGER {
309   KRB5_AUTHDATA_IF_RELEVANT(1),
310   KRB5_AUTHDATA_INTENDED_FOR_SERVER(2),
311   KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS(3),
312   KRB5_AUTHDATA_KDC_ISSUED(4),
313   KRB5_AUTHDATA_AND_OR(5),
314   KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS(6),
315   KRB5_AUTHDATA_IN_TICKET_EXTENSIONS(7),
316   KRB5_AUTHDATA_MANDATORY_FOR_KDC(8),
317   KRB5_AUTHDATA_INITIAL_VERIFIED_CAS(9),
318   KRB5_AUTHDATA_OSF_DCE(64),
319   KRB5_AUTHDATA_SESAME(65),
320   KRB5_AUTHDATA_OSF_DCE_PKI_CERTID(66),
321   KRB5_AUTHDATA_WIN2K_PAC(128),
322   KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION(129),
323   KRB5_AUTHDATA_SIGNTICKET_OLDER(-17),
324   KRB5_AUTHDATA_SIGNTICKET_OLD(142),
325   KRB5_AUTHDATA_SIGNTICKET(512)
326 }
327 */
328
329 typedef enum AUTHDATA_TYPE {
330   KRB5_AUTHDATA_IF_RELEVANT = 1,
331   KRB5_AUTHDATA_INTENDED_FOR_SERVER = 2,
332   KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS = 3,
333   KRB5_AUTHDATA_KDC_ISSUED = 4,
334   KRB5_AUTHDATA_AND_OR = 5,
335   KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS = 6,
336   KRB5_AUTHDATA_IN_TICKET_EXTENSIONS = 7,
337   KRB5_AUTHDATA_MANDATORY_FOR_KDC = 8,
338   KRB5_AUTHDATA_INITIAL_VERIFIED_CAS = 9,
339   KRB5_AUTHDATA_OSF_DCE = 64,
340   KRB5_AUTHDATA_SESAME = 65,
341   KRB5_AUTHDATA_OSF_DCE_PKI_CERTID = 66,
342   KRB5_AUTHDATA_WIN2K_PAC = 128,
343   KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION = 129,
344   KRB5_AUTHDATA_SIGNTICKET_OLDER = -17,
345   KRB5_AUTHDATA_SIGNTICKET_OLD = 142,
346   KRB5_AUTHDATA_SIGNTICKET = 512
347 } AUTHDATA_TYPE;
348
349 ASN1EXP int    ASN1CALL decode_AUTHDATA_TYPE(const unsigned char *, size_t, AUTHDATA_TYPE *, size_t *);
350 ASN1EXP int    ASN1CALL encode_AUTHDATA_TYPE(unsigned char *, size_t, const AUTHDATA_TYPE *, size_t *);
351 ASN1EXP size_t ASN1CALL length_AUTHDATA_TYPE(const AUTHDATA_TYPE *);
352 ASN1EXP int    ASN1CALL copy_AUTHDATA_TYPE  (const AUTHDATA_TYPE *, AUTHDATA_TYPE *);
353 ASN1EXP void   ASN1CALL free_AUTHDATA_TYPE  (AUTHDATA_TYPE *);
354
355
356 /*
357 CKSUMTYPE ::= INTEGER {
358   CKSUMTYPE_NONE(0),
359   CKSUMTYPE_CRC32(1),
360   CKSUMTYPE_RSA_MD4(2),
361   CKSUMTYPE_RSA_MD4_DES(3),
362   CKSUMTYPE_DES_MAC(4),
363   CKSUMTYPE_DES_MAC_K(5),
364   CKSUMTYPE_RSA_MD4_DES_K(6),
365   CKSUMTYPE_RSA_MD5(7),
366   CKSUMTYPE_RSA_MD5_DES(8),
367   CKSUMTYPE_RSA_MD5_DES3(9),
368   CKSUMTYPE_SHA1_OTHER(10),
369   CKSUMTYPE_HMAC_SHA1_DES3(12),
370   CKSUMTYPE_SHA1(14),
371   CKSUMTYPE_HMAC_SHA1_96_AES_128(15),
372   CKSUMTYPE_HMAC_SHA1_96_AES_256(16),
373   CKSUMTYPE_HMAC_SHA256_128_AES128(19),
374   CKSUMTYPE_HMAC_SHA384_192_AES256(20),
375   CKSUMTYPE_GSSAPI(32771),
376   CKSUMTYPE_HMAC_MD5(-138),
377   CKSUMTYPE_HMAC_MD5_ENC(-1138)
378 }
379 */
380
381 typedef enum CKSUMTYPE {
382   CKSUMTYPE_NONE = 0,
383   CKSUMTYPE_CRC32 = 1,
384   CKSUMTYPE_RSA_MD4 = 2,
385   CKSUMTYPE_RSA_MD4_DES = 3,
386   CKSUMTYPE_DES_MAC = 4,
387   CKSUMTYPE_DES_MAC_K = 5,
388   CKSUMTYPE_RSA_MD4_DES_K = 6,
389   CKSUMTYPE_RSA_MD5 = 7,
390   CKSUMTYPE_RSA_MD5_DES = 8,
391   CKSUMTYPE_RSA_MD5_DES3 = 9,
392   CKSUMTYPE_SHA1_OTHER = 10,
393   CKSUMTYPE_HMAC_SHA1_DES3 = 12,
394   CKSUMTYPE_SHA1 = 14,
395   CKSUMTYPE_HMAC_SHA1_96_AES_128 = 15,
396   CKSUMTYPE_HMAC_SHA1_96_AES_256 = 16,
397   CKSUMTYPE_HMAC_SHA256_128_AES128 = 19,
398   CKSUMTYPE_HMAC_SHA384_192_AES256 = 20,
399   CKSUMTYPE_GSSAPI = 32771,
400   CKSUMTYPE_HMAC_MD5 = -138,
401   CKSUMTYPE_HMAC_MD5_ENC = -1138
402 } CKSUMTYPE;
403
404 ASN1EXP int    ASN1CALL decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t *);
405 ASN1EXP int    ASN1CALL encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t *);
406 ASN1EXP size_t ASN1CALL length_CKSUMTYPE(const CKSUMTYPE *);
407 ASN1EXP int    ASN1CALL copy_CKSUMTYPE  (const CKSUMTYPE *, CKSUMTYPE *);
408 ASN1EXP void   ASN1CALL free_CKSUMTYPE  (CKSUMTYPE *);
409
410
411 /*
412 ENCTYPE ::= INTEGER {
413   KRB5_ENCTYPE_NULL(0),
414   KRB5_ENCTYPE_DES_CBC_CRC(1),
415   KRB5_ENCTYPE_DES_CBC_MD4(2),
416   KRB5_ENCTYPE_DES_CBC_MD5(3),
417   KRB5_ENCTYPE_DES3_CBC_MD5(5),
418   KRB5_ENCTYPE_OLD_DES3_CBC_SHA1(7),
419   KRB5_ENCTYPE_SIGN_DSA_GENERATE(8),
420   KRB5_ENCTYPE_ENCRYPT_RSA_PRIV(9),
421   KRB5_ENCTYPE_ENCRYPT_RSA_PUB(10),
422   KRB5_ENCTYPE_DES3_CBC_SHA1(16),
423   KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96(17),
424   KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96(18),
425   KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128(19),
426   KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192(20),
427   KRB5_ENCTYPE_ARCFOUR_HMAC_MD5(23),
428   KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56(24),
429   KRB5_ENCTYPE_ENCTYPE_PK_CROSS(48),
430   KRB5_ENCTYPE_ARCFOUR_MD4(-128),
431   KRB5_ENCTYPE_ARCFOUR_HMAC_OLD(-133),
432   KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP(-135),
433   KRB5_ENCTYPE_DES_CBC_NONE(-4096),
434   KRB5_ENCTYPE_DES3_CBC_NONE(-4097),
435   KRB5_ENCTYPE_DES_CFB64_NONE(-4098),
436   KRB5_ENCTYPE_DES_PCBC_NONE(-4099),
437   KRB5_ENCTYPE_DIGEST_MD5_NONE(-4100),
438   KRB5_ENCTYPE_CRAM_MD5_NONE(-4101)
439 }
440 */
441
442 typedef enum ENCTYPE {
443   KRB5_ENCTYPE_NULL = 0,
444   KRB5_ENCTYPE_DES_CBC_CRC = 1,
445   KRB5_ENCTYPE_DES_CBC_MD4 = 2,
446   KRB5_ENCTYPE_DES_CBC_MD5 = 3,
447   KRB5_ENCTYPE_DES3_CBC_MD5 = 5,
448   KRB5_ENCTYPE_OLD_DES3_CBC_SHA1 = 7,
449   KRB5_ENCTYPE_SIGN_DSA_GENERATE = 8,
450   KRB5_ENCTYPE_ENCRYPT_RSA_PRIV = 9,
451   KRB5_ENCTYPE_ENCRYPT_RSA_PUB = 10,
452   KRB5_ENCTYPE_DES3_CBC_SHA1 = 16,
453   KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96 = 17,
454   KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96 = 18,
455   KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128 = 19,
456   KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192 = 20,
457   KRB5_ENCTYPE_ARCFOUR_HMAC_MD5 = 23,
458   KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56 = 24,
459   KRB5_ENCTYPE_ENCTYPE_PK_CROSS = 48,
460   KRB5_ENCTYPE_ARCFOUR_MD4 = -128,
461   KRB5_ENCTYPE_ARCFOUR_HMAC_OLD = -133,
462   KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP = -135,
463   KRB5_ENCTYPE_DES_CBC_NONE = -4096,
464   KRB5_ENCTYPE_DES3_CBC_NONE = -4097,
465   KRB5_ENCTYPE_DES_CFB64_NONE = -4098,
466   KRB5_ENCTYPE_DES_PCBC_NONE = -4099,
467   KRB5_ENCTYPE_DIGEST_MD5_NONE = -4100,
468   KRB5_ENCTYPE_CRAM_MD5_NONE = -4101
469 } ENCTYPE;
470
471 ASN1EXP int    ASN1CALL decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *);
472 ASN1EXP int    ASN1CALL encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *);
473 ASN1EXP size_t ASN1CALL length_ENCTYPE(const ENCTYPE *);
474 ASN1EXP int    ASN1CALL copy_ENCTYPE  (const ENCTYPE *, ENCTYPE *);
475 ASN1EXP void   ASN1CALL free_ENCTYPE  (ENCTYPE *);
476
477
478 /*
479 krb5uint32 ::= INTEGER (0..4294967295)
480 */
481
482 typedef unsigned int krb5uint32;
483
484 /*
485 krb5int32 ::= INTEGER (-2147483648..2147483647)
486 */
487
488 typedef int krb5int32;
489
490 /*
491 KerberosString ::= GeneralString
492 */
493
494 typedef heim_general_string KerberosString;
495
496 ASN1EXP int    ASN1CALL decode_KerberosString(const unsigned char *, size_t, KerberosString *, size_t *);
497 ASN1EXP int    ASN1CALL encode_KerberosString(unsigned char *, size_t, const KerberosString *, size_t *);
498 ASN1EXP size_t ASN1CALL length_KerberosString(const KerberosString *);
499 ASN1EXP int    ASN1CALL copy_KerberosString  (const KerberosString *, KerberosString *);
500 ASN1EXP void   ASN1CALL free_KerberosString  (KerberosString *);
501
502
503 /*
504 Realm ::= GeneralString
505 */
506
507 typedef heim_general_string Realm;
508
509 ASN1EXP int    ASN1CALL decode_Realm(const unsigned char *, size_t, Realm *, size_t *);
510 ASN1EXP int    ASN1CALL encode_Realm(unsigned char *, size_t, const Realm *, size_t *);
511 ASN1EXP size_t ASN1CALL length_Realm(const Realm *);
512 ASN1EXP int    ASN1CALL copy_Realm  (const Realm *, Realm *);
513 ASN1EXP void   ASN1CALL free_Realm  (Realm *);
514
515
516 /*
517 PrincipalName ::= SEQUENCE {
518   name-type       [0] NAME-TYPE,
519   name-string     [1] SEQUENCE OF GeneralString,
520 }
521 */
522
523 typedef struct PrincipalName {
524   NAME_TYPE name_type;
525   struct PrincipalName_name_string {
526     unsigned int len;
527     heim_general_string *val;
528   } name_string;
529 } PrincipalName;
530
531 ASN1EXP int    ASN1CALL decode_PrincipalName(const unsigned char *, size_t, PrincipalName *, size_t *);
532 ASN1EXP int    ASN1CALL encode_PrincipalName(unsigned char *, size_t, const PrincipalName *, size_t *);
533 ASN1EXP size_t ASN1CALL length_PrincipalName(const PrincipalName *);
534 ASN1EXP int    ASN1CALL copy_PrincipalName  (const PrincipalName *, PrincipalName *);
535 ASN1EXP void   ASN1CALL free_PrincipalName  (PrincipalName *);
536
537
538 /*
539 Principal ::= SEQUENCE {
540   name            [0] PrincipalName,
541   realm           [1] Realm,
542 }
543 */
544
545 typedef struct Principal {
546   PrincipalName name;
547   Realm realm;
548 } Principal;
549
550 ASN1EXP int    ASN1CALL decode_Principal(const unsigned char *, size_t, Principal *, size_t *);
551 ASN1EXP int    ASN1CALL encode_Principal(unsigned char *, size_t, const Principal *, size_t *);
552 ASN1EXP size_t ASN1CALL length_Principal(const Principal *);
553 ASN1EXP int    ASN1CALL copy_Principal  (const Principal *, Principal *);
554 ASN1EXP void   ASN1CALL free_Principal  (Principal *);
555
556
557 /*
558 Principals ::= SEQUENCE OF Principal
559 */
560
561 typedef struct Principals {
562   unsigned int len;
563   Principal *val;
564 } Principals;
565
566 ASN1EXP int   ASN1CALL add_Principals  (Principals *, const Principal *);
567 ASN1EXP int   ASN1CALL remove_Principals  (Principals *, unsigned int);
568 ASN1EXP int    ASN1CALL decode_Principals(const unsigned char *, size_t, Principals *, size_t *);
569 ASN1EXP int    ASN1CALL encode_Principals(unsigned char *, size_t, const Principals *, size_t *);
570 ASN1EXP size_t ASN1CALL length_Principals(const Principals *);
571 ASN1EXP int    ASN1CALL copy_Principals  (const Principals *, Principals *);
572 ASN1EXP void   ASN1CALL free_Principals  (Principals *);
573
574
575 /*
576 HostAddress ::= SEQUENCE {
577   addr-type       [0] krb5int32,
578   address         [1] OCTET STRING,
579 }
580 */
581
582 typedef struct HostAddress {
583   krb5int32 addr_type;
584   heim_octet_string address;
585 } HostAddress;
586
587 ASN1EXP int    ASN1CALL decode_HostAddress(const unsigned char *, size_t, HostAddress *, size_t *);
588 ASN1EXP int    ASN1CALL encode_HostAddress(unsigned char *, size_t, const HostAddress *, size_t *);
589 ASN1EXP size_t ASN1CALL length_HostAddress(const HostAddress *);
590 ASN1EXP int    ASN1CALL copy_HostAddress  (const HostAddress *, HostAddress *);
591 ASN1EXP void   ASN1CALL free_HostAddress  (HostAddress *);
592
593
594 /*
595 HostAddresses ::= SEQUENCE OF HostAddress
596 */
597
598 typedef struct HostAddresses {
599   unsigned int len;
600   HostAddress *val;
601 } HostAddresses;
602
603 ASN1EXP int    ASN1CALL decode_HostAddresses(const unsigned char *, size_t, HostAddresses *, size_t *);
604 ASN1EXP int    ASN1CALL encode_HostAddresses(unsigned char *, size_t, const HostAddresses *, size_t *);
605 ASN1EXP size_t ASN1CALL length_HostAddresses(const HostAddresses *);
606 ASN1EXP int    ASN1CALL copy_HostAddresses  (const HostAddresses *, HostAddresses *);
607 ASN1EXP void   ASN1CALL free_HostAddresses  (HostAddresses *);
608
609
610 /*
611 KerberosTime ::= GeneralizedTime
612 */
613
614 typedef time_t KerberosTime;
615
616 ASN1EXP int    ASN1CALL decode_KerberosTime(const unsigned char *, size_t, KerberosTime *, size_t *);
617 ASN1EXP int    ASN1CALL encode_KerberosTime(unsigned char *, size_t, const KerberosTime *, size_t *);
618 ASN1EXP size_t ASN1CALL length_KerberosTime(const KerberosTime *);
619 ASN1EXP int    ASN1CALL copy_KerberosTime  (const KerberosTime *, KerberosTime *);
620 ASN1EXP void   ASN1CALL free_KerberosTime  (KerberosTime *);
621
622
623 /*
624 AuthorizationDataElement ::= SEQUENCE {
625   ad-type         [0] krb5int32,
626   ad-data         [1] OCTET STRING,
627 }
628 */
629
630 typedef struct AuthorizationDataElement {
631   krb5int32 ad_type;
632   heim_octet_string ad_data;
633 } AuthorizationDataElement;
634
635 ASN1EXP int    ASN1CALL decode_AuthorizationDataElement(const unsigned char *, size_t, AuthorizationDataElement *, size_t *);
636 ASN1EXP int    ASN1CALL encode_AuthorizationDataElement(unsigned char *, size_t, const AuthorizationDataElement *, size_t *);
637 ASN1EXP size_t ASN1CALL length_AuthorizationDataElement(const AuthorizationDataElement *);
638 ASN1EXP int    ASN1CALL copy_AuthorizationDataElement  (const AuthorizationDataElement *, AuthorizationDataElement *);
639 ASN1EXP void   ASN1CALL free_AuthorizationDataElement  (AuthorizationDataElement *);
640
641
642 /*
643 AuthorizationData ::= SEQUENCE OF AuthorizationDataElement
644 */
645
646 typedef struct AuthorizationData {
647   unsigned int len;
648   AuthorizationDataElement *val;
649 } AuthorizationData;
650
651 ASN1EXP int   ASN1CALL add_AuthorizationData  (AuthorizationData *, const AuthorizationDataElement *);
652 ASN1EXP int   ASN1CALL remove_AuthorizationData  (AuthorizationData *, unsigned int);
653 ASN1EXP int    ASN1CALL decode_AuthorizationData(const unsigned char *, size_t, AuthorizationData *, size_t *);
654 ASN1EXP int    ASN1CALL encode_AuthorizationData(unsigned char *, size_t, const AuthorizationData *, size_t *);
655 ASN1EXP size_t ASN1CALL length_AuthorizationData(const AuthorizationData *);
656 ASN1EXP int    ASN1CALL copy_AuthorizationData  (const AuthorizationData *, AuthorizationData *);
657 ASN1EXP void   ASN1CALL free_AuthorizationData  (AuthorizationData *);
658
659
660 /*
661 APOptions ::= BIT STRING {
662   reserved(0),
663   use-session-key(1),
664   mutual-required(2)
665 }
666 */
667
668 typedef struct APOptions {
669   unsigned int reserved:1;
670   unsigned int use_session_key:1;
671   unsigned int mutual_required:1;
672   unsigned int _unused3:1;
673   unsigned int _unused4:1;
674   unsigned int _unused5:1;
675   unsigned int _unused6:1;
676   unsigned int _unused7:1;
677   unsigned int _unused8:1;
678   unsigned int _unused9:1;
679   unsigned int _unused10:1;
680   unsigned int _unused11:1;
681   unsigned int _unused12:1;
682   unsigned int _unused13:1;
683   unsigned int _unused14:1;
684   unsigned int _unused15:1;
685   unsigned int _unused16:1;
686   unsigned int _unused17:1;
687   unsigned int _unused18:1;
688   unsigned int _unused19:1;
689   unsigned int _unused20:1;
690   unsigned int _unused21:1;
691   unsigned int _unused22:1;
692   unsigned int _unused23:1;
693   unsigned int _unused24:1;
694   unsigned int _unused25:1;
695   unsigned int _unused26:1;
696   unsigned int _unused27:1;
697   unsigned int _unused28:1;
698   unsigned int _unused29:1;
699   unsigned int _unused30:1;
700   unsigned int _unused31:1;
701 } APOptions;
702
703
704 unsigned APOptions2int(APOptions);
705 APOptions int2APOptions(unsigned);
706 /*
707 TicketFlags ::= BIT STRING {
708   reserved(0),
709   forwardable(1),
710   forwarded(2),
711   proxiable(3),
712   proxy(4),
713   may-postdate(5),
714   postdated(6),
715   invalid(7),
716   renewable(8),
717   initial(9),
718   pre-authent(10),
719   hw-authent(11),
720   transited-policy-checked(12),
721   ok-as-delegate(13),
722   enc-pa-rep(15),
723   anonymous(16)
724 }
725 */
726
727 typedef struct TicketFlags {
728   unsigned int reserved:1;
729   unsigned int forwardable:1;
730   unsigned int forwarded:1;
731   unsigned int proxiable:1;
732   unsigned int proxy:1;
733   unsigned int may_postdate:1;
734   unsigned int postdated:1;
735   unsigned int invalid:1;
736   unsigned int renewable:1;
737   unsigned int initial:1;
738   unsigned int pre_authent:1;
739   unsigned int hw_authent:1;
740   unsigned int transited_policy_checked:1;
741   unsigned int ok_as_delegate:1;
742   unsigned int _unused14:1;
743   unsigned int enc_pa_rep:1;
744   unsigned int anonymous:1;
745   unsigned int _unused17:1;
746   unsigned int _unused18:1;
747   unsigned int _unused19:1;
748   unsigned int _unused20:1;
749   unsigned int _unused21:1;
750   unsigned int _unused22:1;
751   unsigned int _unused23:1;
752   unsigned int _unused24:1;
753   unsigned int _unused25:1;
754   unsigned int _unused26:1;
755   unsigned int _unused27:1;
756   unsigned int _unused28:1;
757   unsigned int _unused29:1;
758   unsigned int _unused30:1;
759   unsigned int _unused31:1;
760 } TicketFlags;
761
762
763 unsigned TicketFlags2int(TicketFlags);
764 TicketFlags int2TicketFlags(unsigned);
765 ASN1EXP int    ASN1CALL decode_TicketFlags(const unsigned char *, size_t, TicketFlags *, size_t *);
766 ASN1EXP int    ASN1CALL encode_TicketFlags(unsigned char *, size_t, const TicketFlags *, size_t *);
767 ASN1EXP size_t ASN1CALL length_TicketFlags(const TicketFlags *);
768 ASN1EXP int    ASN1CALL copy_TicketFlags  (const TicketFlags *, TicketFlags *);
769 ASN1EXP void   ASN1CALL free_TicketFlags  (TicketFlags *);
770
771
772 /*
773 KDCOptions ::= BIT STRING {
774   reserved(0),
775   forwardable(1),
776   forwarded(2),
777   proxiable(3),
778   proxy(4),
779   allow-postdate(5),
780   postdated(6),
781   renewable(8),
782   cname-in-addl-tkt(14),
783   canonicalize(15),
784   request-anonymous(16),
785   disable-transited-check(26),
786   renewable-ok(27),
787   enc-tkt-in-skey(28),
788   renew(30),
789   validate(31)
790 }
791 */
792
793 typedef struct KDCOptions {
794   unsigned int reserved:1;
795   unsigned int forwardable:1;
796   unsigned int forwarded:1;
797   unsigned int proxiable:1;
798   unsigned int proxy:1;
799   unsigned int allow_postdate:1;
800   unsigned int postdated:1;
801   unsigned int _unused7:1;
802   unsigned int renewable:1;
803   unsigned int _unused9:1;
804   unsigned int _unused10:1;
805   unsigned int _unused11:1;
806   unsigned int _unused12:1;
807   unsigned int _unused13:1;
808   unsigned int cname_in_addl_tkt:1;
809   unsigned int canonicalize:1;
810   unsigned int request_anonymous:1;
811   unsigned int _unused17:1;
812   unsigned int _unused18:1;
813   unsigned int _unused19:1;
814   unsigned int _unused20:1;
815   unsigned int _unused21:1;
816   unsigned int _unused22:1;
817   unsigned int _unused23:1;
818   unsigned int _unused24:1;
819   unsigned int _unused25:1;
820   unsigned int disable_transited_check:1;
821   unsigned int renewable_ok:1;
822   unsigned int enc_tkt_in_skey:1;
823   unsigned int _unused29:1;
824   unsigned int renew:1;
825   unsigned int validate:1;
826 } KDCOptions;
827
828
829 unsigned KDCOptions2int(KDCOptions);
830 KDCOptions int2KDCOptions(unsigned);
831 ASN1EXP int    ASN1CALL decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_t *);
832 ASN1EXP int    ASN1CALL encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_t *);
833 ASN1EXP size_t ASN1CALL length_KDCOptions(const KDCOptions *);
834 ASN1EXP int    ASN1CALL copy_KDCOptions  (const KDCOptions *, KDCOptions *);
835 ASN1EXP void   ASN1CALL free_KDCOptions  (KDCOptions *);
836
837
838 /*
839 LR-TYPE ::= INTEGER {
840   LR_NONE(0),
841   LR_INITIAL_TGT(1),
842   LR_INITIAL(2),
843   LR_ISSUE_USE_TGT(3),
844   LR_RENEWAL(4),
845   LR_REQUEST(5),
846   LR_PW_EXPTIME(6),
847   LR_ACCT_EXPTIME(7)
848 }
849 */
850
851 typedef enum LR_TYPE {
852   LR_NONE = 0,
853   LR_INITIAL_TGT = 1,
854   LR_INITIAL = 2,
855   LR_ISSUE_USE_TGT = 3,
856   LR_RENEWAL = 4,
857   LR_REQUEST = 5,
858   LR_PW_EXPTIME = 6,
859   LR_ACCT_EXPTIME = 7
860 } LR_TYPE;
861
862 ASN1EXP int    ASN1CALL decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *);
863 ASN1EXP int    ASN1CALL encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *);
864 ASN1EXP size_t ASN1CALL length_LR_TYPE(const LR_TYPE *);
865 ASN1EXP int    ASN1CALL copy_LR_TYPE  (const LR_TYPE *, LR_TYPE *);
866 ASN1EXP void   ASN1CALL free_LR_TYPE  (LR_TYPE *);
867
868
869 /*
870 LastReq ::= SEQUENCE OF SEQUENCE {
871   lr-type         [0] LR-TYPE,
872   lr-value        [1] KerberosTime,
873 }
874 */
875
876 typedef struct LastReq {
877   unsigned int len;
878   struct LastReq_val {
879     LR_TYPE lr_type;
880     KerberosTime lr_value;
881   } *val;
882 } LastReq;
883
884 ASN1EXP int    ASN1CALL decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *);
885 ASN1EXP int    ASN1CALL encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *);
886 ASN1EXP size_t ASN1CALL length_LastReq(const LastReq *);
887 ASN1EXP int    ASN1CALL copy_LastReq  (const LastReq *, LastReq *);
888 ASN1EXP void   ASN1CALL free_LastReq  (LastReq *);
889
890
891 /*
892 EncryptedData ::= SEQUENCE {
893   etype           [0] ENCTYPE,
894   kvno            [1] krb5int32 OPTIONAL,
895   cipher          [2] OCTET STRING,
896 }
897 */
898
899 typedef struct EncryptedData {
900   ENCTYPE etype;
901   krb5int32 *kvno;
902   heim_octet_string cipher;
903 } EncryptedData;
904
905 ASN1EXP int    ASN1CALL decode_EncryptedData(const unsigned char *, size_t, EncryptedData *, size_t *);
906 ASN1EXP int    ASN1CALL encode_EncryptedData(unsigned char *, size_t, const EncryptedData *, size_t *);
907 ASN1EXP size_t ASN1CALL length_EncryptedData(const EncryptedData *);
908 ASN1EXP int    ASN1CALL copy_EncryptedData  (const EncryptedData *, EncryptedData *);
909 ASN1EXP void   ASN1CALL free_EncryptedData  (EncryptedData *);
910
911
912 /*
913 EncryptionKey ::= SEQUENCE {
914   keytype         [0] krb5int32,
915   keyvalue        [1] OCTET STRING,
916 }
917 */
918
919 typedef struct EncryptionKey {
920   krb5int32 keytype;
921   heim_octet_string keyvalue;
922 } EncryptionKey;
923
924 ASN1EXP int    ASN1CALL decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *, size_t *);
925 ASN1EXP int    ASN1CALL encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *, size_t *);
926 ASN1EXP size_t ASN1CALL length_EncryptionKey(const EncryptionKey *);
927 ASN1EXP int    ASN1CALL copy_EncryptionKey  (const EncryptionKey *, EncryptionKey *);
928 ASN1EXP void   ASN1CALL free_EncryptionKey  (EncryptionKey *);
929
930
931 /*
932 TransitedEncoding ::= SEQUENCE {
933   tr-type         [0] krb5int32,
934   contents        [1] OCTET STRING,
935 }
936 */
937
938 typedef struct TransitedEncoding {
939   krb5int32 tr_type;
940   heim_octet_string contents;
941 } TransitedEncoding;
942
943 ASN1EXP int    ASN1CALL decode_TransitedEncoding(const unsigned char *, size_t, TransitedEncoding *, size_t *);
944 ASN1EXP int    ASN1CALL encode_TransitedEncoding(unsigned char *, size_t, const TransitedEncoding *, size_t *);
945 ASN1EXP size_t ASN1CALL length_TransitedEncoding(const TransitedEncoding *);
946 ASN1EXP int    ASN1CALL copy_TransitedEncoding  (const TransitedEncoding *, TransitedEncoding *);
947 ASN1EXP void   ASN1CALL free_TransitedEncoding  (TransitedEncoding *);
948
949
950 /*
951 Ticket ::= [APPLICATION 1] SEQUENCE {
952   tkt-vno         [0] krb5int32,
953   realm           [1] Realm,
954   sname           [2] PrincipalName,
955   enc-part        [3] EncryptedData,
956 }
957 */
958
959 typedef struct Ticket {
960   krb5int32 tkt_vno;
961   Realm realm;
962   PrincipalName sname;
963   EncryptedData enc_part;
964 } Ticket;
965
966 ASN1EXP int    ASN1CALL decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *);
967 ASN1EXP int    ASN1CALL encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *);
968 ASN1EXP size_t ASN1CALL length_Ticket(const Ticket *);
969 ASN1EXP int    ASN1CALL copy_Ticket  (const Ticket *, Ticket *);
970 ASN1EXP void   ASN1CALL free_Ticket  (Ticket *);
971
972
973 /*
974 EncTicketPart ::= [APPLICATION 3] SEQUENCE {
975   flags                [0] TicketFlags,
976   key                  [1] EncryptionKey,
977   crealm               [2] Realm,
978   cname                [3] PrincipalName,
979   transited            [4] TransitedEncoding,
980   authtime             [5] KerberosTime,
981   starttime            [6] KerberosTime OPTIONAL,
982   endtime              [7] KerberosTime,
983   renew-till           [8] KerberosTime OPTIONAL,
984   caddr                [9] HostAddresses OPTIONAL,
985   authorization-data   [10] AuthorizationData OPTIONAL,
986 }
987 */
988
989 typedef struct EncTicketPart {
990   TicketFlags flags;
991   EncryptionKey key;
992   Realm crealm;
993   PrincipalName cname;
994   TransitedEncoding transited;
995   KerberosTime authtime;
996   KerberosTime *starttime;
997   KerberosTime endtime;
998   KerberosTime *renew_till;
999   HostAddresses *caddr;
1000   AuthorizationData *authorization_data;
1001 } EncTicketPart;
1002
1003 ASN1EXP int    ASN1CALL decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *, size_t *);
1004 ASN1EXP int    ASN1CALL encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *, size_t *);
1005 ASN1EXP size_t ASN1CALL length_EncTicketPart(const EncTicketPart *);
1006 ASN1EXP int    ASN1CALL copy_EncTicketPart  (const EncTicketPart *, EncTicketPart *);
1007 ASN1EXP void   ASN1CALL free_EncTicketPart  (EncTicketPart *);
1008
1009
1010 /*
1011 Checksum ::= SEQUENCE {
1012   cksumtype       [0] CKSUMTYPE,
1013   checksum        [1] OCTET STRING,
1014 }
1015 */
1016
1017 typedef struct Checksum {
1018   CKSUMTYPE cksumtype;
1019   heim_octet_string checksum;
1020 } Checksum;
1021
1022 ASN1EXP int    ASN1CALL decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *);
1023 ASN1EXP int    ASN1CALL encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *);
1024 ASN1EXP size_t ASN1CALL length_Checksum(const Checksum *);
1025 ASN1EXP int    ASN1CALL copy_Checksum  (const Checksum *, Checksum *);
1026 ASN1EXP void   ASN1CALL free_Checksum  (Checksum *);
1027
1028
1029 /*
1030 Authenticator ::= [APPLICATION 2] SEQUENCE {
1031   authenticator-vno    [0] krb5int32,
1032   crealm               [1] Realm,
1033   cname                [2] PrincipalName,
1034   cksum                [3] Checksum OPTIONAL,
1035   cusec                [4] krb5int32,
1036   ctime                [5] KerberosTime,
1037   subkey               [6] EncryptionKey OPTIONAL,
1038   seq-number           [7] krb5uint32 OPTIONAL,
1039   authorization-data   [8] AuthorizationData OPTIONAL,
1040 }
1041 */
1042
1043 typedef struct Authenticator {
1044   krb5int32 authenticator_vno;
1045   Realm crealm;
1046   PrincipalName cname;
1047   Checksum *cksum;
1048   krb5int32 cusec;
1049   KerberosTime ctime;
1050   EncryptionKey *subkey;
1051   krb5uint32 *seq_number;
1052   AuthorizationData *authorization_data;
1053 } Authenticator;
1054
1055 ASN1EXP int    ASN1CALL decode_Authenticator(const unsigned char *, size_t, Authenticator *, size_t *);
1056 ASN1EXP int    ASN1CALL encode_Authenticator(unsigned char *, size_t, const Authenticator *, size_t *);
1057 ASN1EXP size_t ASN1CALL length_Authenticator(const Authenticator *);
1058 ASN1EXP int    ASN1CALL copy_Authenticator  (const Authenticator *, Authenticator *);
1059 ASN1EXP void   ASN1CALL free_Authenticator  (Authenticator *);
1060
1061
1062 /*
1063 PA-DATA ::= SEQUENCE {
1064   padata-type     [1] PADATA-TYPE,
1065   padata-value    [2] OCTET STRING,
1066 }
1067 */
1068
1069 typedef struct PA_DATA {
1070   PADATA_TYPE padata_type;
1071   heim_octet_string padata_value;
1072 } PA_DATA;
1073
1074 ASN1EXP int    ASN1CALL decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *);
1075 ASN1EXP int    ASN1CALL encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *);
1076 ASN1EXP size_t ASN1CALL length_PA_DATA(const PA_DATA *);
1077 ASN1EXP int    ASN1CALL copy_PA_DATA  (const PA_DATA *, PA_DATA *);
1078 ASN1EXP void   ASN1CALL free_PA_DATA  (PA_DATA *);
1079
1080
1081 /*
1082 ETYPE-INFO-ENTRY ::= SEQUENCE {
1083   etype           [0] ENCTYPE,
1084   salt            [1] OCTET STRING OPTIONAL,
1085   salttype        [2] krb5int32 OPTIONAL,
1086 }
1087 */
1088
1089 typedef struct ETYPE_INFO_ENTRY {
1090   ENCTYPE etype;
1091   heim_octet_string *salt;
1092   krb5int32 *salttype;
1093 } ETYPE_INFO_ENTRY;
1094
1095 ASN1EXP int    ASN1CALL decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_ENTRY *, size_t *);
1096 ASN1EXP int    ASN1CALL encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_ENTRY *, size_t *);
1097 ASN1EXP size_t ASN1CALL length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *);
1098 ASN1EXP int    ASN1CALL copy_ETYPE_INFO_ENTRY  (const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY *);
1099 ASN1EXP void   ASN1CALL free_ETYPE_INFO_ENTRY  (ETYPE_INFO_ENTRY *);
1100
1101
1102 /*
1103 ETYPE-INFO ::= SEQUENCE OF ETYPE-INFO-ENTRY
1104 */
1105
1106 typedef struct ETYPE_INFO {
1107   unsigned int len;
1108   ETYPE_INFO_ENTRY *val;
1109 } ETYPE_INFO;
1110
1111 ASN1EXP int   ASN1CALL add_ETYPE_INFO  (ETYPE_INFO *, const ETYPE_INFO_ENTRY *);
1112 ASN1EXP int   ASN1CALL remove_ETYPE_INFO  (ETYPE_INFO *, unsigned int);
1113 ASN1EXP int    ASN1CALL decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_t *);
1114 ASN1EXP int    ASN1CALL encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_t *);
1115 ASN1EXP size_t ASN1CALL length_ETYPE_INFO(const ETYPE_INFO *);
1116 ASN1EXP int    ASN1CALL copy_ETYPE_INFO  (const ETYPE_INFO *, ETYPE_INFO *);
1117 ASN1EXP void   ASN1CALL free_ETYPE_INFO  (ETYPE_INFO *);
1118
1119
1120 /*
1121 ETYPE-INFO2-ENTRY ::= SEQUENCE {
1122   etype           [0] ENCTYPE,
1123   salt            [1] KerberosString OPTIONAL,
1124   s2kparams       [2] OCTET STRING OPTIONAL,
1125 }
1126 */
1127
1128 typedef struct ETYPE_INFO2_ENTRY {
1129   ENCTYPE etype;
1130   KerberosString *salt;
1131   heim_octet_string *s2kparams;
1132 } ETYPE_INFO2_ENTRY;
1133
1134 ASN1EXP int    ASN1CALL decode_ETYPE_INFO2_ENTRY(const unsigned char *, size_t, ETYPE_INFO2_ENTRY *, size_t *);
1135 ASN1EXP int    ASN1CALL encode_ETYPE_INFO2_ENTRY(unsigned char *, size_t, const ETYPE_INFO2_ENTRY *, size_t *);
1136 ASN1EXP size_t ASN1CALL length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *);
1137 ASN1EXP int    ASN1CALL copy_ETYPE_INFO2_ENTRY  (const ETYPE_INFO2_ENTRY *, ETYPE_INFO2_ENTRY *);
1138 ASN1EXP void   ASN1CALL free_ETYPE_INFO2_ENTRY  (ETYPE_INFO2_ENTRY *);
1139
1140
1141 /*
1142 ETYPE-INFO2 ::= SEQUENCE OF ETYPE-INFO2-ENTRY
1143 */
1144
1145 typedef struct ETYPE_INFO2 {
1146   unsigned int len;
1147   ETYPE_INFO2_ENTRY *val;
1148 } ETYPE_INFO2;
1149
1150 ASN1EXP int   ASN1CALL add_ETYPE_INFO2  (ETYPE_INFO2 *, const ETYPE_INFO2_ENTRY *);
1151 ASN1EXP int   ASN1CALL remove_ETYPE_INFO2  (ETYPE_INFO2 *, unsigned int);
1152 ASN1EXP int    ASN1CALL decode_ETYPE_INFO2(const unsigned char *, size_t, ETYPE_INFO2 *, size_t *);
1153 ASN1EXP int    ASN1CALL encode_ETYPE_INFO2(unsigned char *, size_t, const ETYPE_INFO2 *, size_t *);
1154 ASN1EXP size_t ASN1CALL length_ETYPE_INFO2(const ETYPE_INFO2 *);
1155 ASN1EXP int    ASN1CALL copy_ETYPE_INFO2  (const ETYPE_INFO2 *, ETYPE_INFO2 *);
1156 ASN1EXP void   ASN1CALL free_ETYPE_INFO2  (ETYPE_INFO2 *);
1157
1158
1159 /*
1160 METHOD-DATA ::= SEQUENCE OF PA-DATA
1161 */
1162
1163 typedef struct METHOD_DATA {
1164   unsigned int len;
1165   PA_DATA *val;
1166 } METHOD_DATA;
1167
1168 ASN1EXP int   ASN1CALL add_METHOD_DATA  (METHOD_DATA *, const PA_DATA *);
1169 ASN1EXP int   ASN1CALL remove_METHOD_DATA  (METHOD_DATA *, unsigned int);
1170 ASN1EXP int    ASN1CALL decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *, size_t *);
1171 ASN1EXP int    ASN1CALL encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *, size_t *);
1172 ASN1EXP size_t ASN1CALL length_METHOD_DATA(const METHOD_DATA *);
1173 ASN1EXP int    ASN1CALL copy_METHOD_DATA  (const METHOD_DATA *, METHOD_DATA *);
1174 ASN1EXP void   ASN1CALL free_METHOD_DATA  (METHOD_DATA *);
1175
1176
1177 /*
1178 TypedData ::= SEQUENCE {
1179   data-type       [0] krb5int32,
1180   data-value      [1] OCTET STRING OPTIONAL,
1181 }
1182 */
1183
1184 typedef struct TypedData {
1185   krb5int32 data_type;
1186   heim_octet_string *data_value;
1187 } TypedData;
1188
1189 ASN1EXP int    ASN1CALL decode_TypedData(const unsigned char *, size_t, TypedData *, size_t *);
1190 ASN1EXP int    ASN1CALL encode_TypedData(unsigned char *, size_t, const TypedData *, size_t *);
1191 ASN1EXP size_t ASN1CALL length_TypedData(const TypedData *);
1192 ASN1EXP int    ASN1CALL copy_TypedData  (const TypedData *, TypedData *);
1193 ASN1EXP void   ASN1CALL free_TypedData  (TypedData *);
1194
1195
1196 /*
1197 TYPED-DATA ::= SEQUENCE OF TypedData
1198 */
1199
1200 typedef struct TYPED_DATA {
1201   unsigned int len;
1202   TypedData *val;
1203 } TYPED_DATA;
1204
1205 /*
1206 KDC-REQ-BODY ::= SEQUENCE {
1207   kdc-options              [0] KDCOptions,
1208   cname                    [1] PrincipalName OPTIONAL,
1209   realm                    [2] Realm,
1210   sname                    [3] PrincipalName OPTIONAL,
1211   from                     [4] KerberosTime OPTIONAL,
1212   till                     [5] KerberosTime OPTIONAL,
1213   rtime                    [6] KerberosTime OPTIONAL,
1214   nonce                    [7] krb5int32,
1215   etype                    [8] SEQUENCE OF ENCTYPE,
1216   addresses                [9] HostAddresses OPTIONAL,
1217   enc-authorization-data   [10] EncryptedData OPTIONAL,
1218   additional-tickets       [11] SEQUENCE OF Ticket OPTIONAL,
1219 }
1220 */
1221
1222 typedef struct KDC_REQ_BODY {
1223   KDCOptions kdc_options;
1224   PrincipalName *cname;
1225   Realm realm;
1226   PrincipalName *sname;
1227   KerberosTime *from;
1228   KerberosTime *till;
1229   KerberosTime *rtime;
1230   krb5int32 nonce;
1231   struct KDC_REQ_BODY_etype {
1232     unsigned int len;
1233     ENCTYPE *val;
1234   } etype;
1235   HostAddresses *addresses;
1236   EncryptedData *enc_authorization_data;
1237   struct KDC_REQ_BODY_additional_tickets {
1238     unsigned int len;
1239     Ticket *val;
1240   } *additional_tickets;
1241 } KDC_REQ_BODY;
1242
1243 ASN1EXP int    ASN1CALL decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *, size_t *);
1244 ASN1EXP int    ASN1CALL encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *, size_t *);
1245 ASN1EXP size_t ASN1CALL length_KDC_REQ_BODY(const KDC_REQ_BODY *);
1246 ASN1EXP int    ASN1CALL copy_KDC_REQ_BODY  (const KDC_REQ_BODY *, KDC_REQ_BODY *);
1247 ASN1EXP void   ASN1CALL free_KDC_REQ_BODY  (KDC_REQ_BODY *);
1248
1249
1250 /*
1251 KDC-REQ ::= SEQUENCE {
1252   pvno            [1] krb5int32,
1253   msg-type        [2] MESSAGE-TYPE,
1254   padata          [3] METHOD-DATA OPTIONAL,
1255   req-body        [4] KDC-REQ-BODY,
1256 }
1257 */
1258
1259 typedef struct KDC_REQ {
1260   krb5int32 pvno;
1261   MESSAGE_TYPE msg_type;
1262   METHOD_DATA *padata;
1263   KDC_REQ_BODY req_body;
1264 } KDC_REQ;
1265
1266 /*
1267 AS-REQ ::= [APPLICATION 10] KDC-REQ
1268 */
1269
1270 typedef KDC_REQ AS_REQ;
1271
1272 ASN1EXP int    ASN1CALL decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *);
1273 ASN1EXP int    ASN1CALL encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *);
1274 ASN1EXP size_t ASN1CALL length_AS_REQ(const AS_REQ *);
1275 ASN1EXP int    ASN1CALL copy_AS_REQ  (const AS_REQ *, AS_REQ *);
1276 ASN1EXP void   ASN1CALL free_AS_REQ  (AS_REQ *);
1277
1278
1279 /*
1280 TGS-REQ ::= [APPLICATION 12] KDC-REQ
1281 */
1282
1283 typedef KDC_REQ TGS_REQ;
1284
1285 ASN1EXP int    ASN1CALL decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *);
1286 ASN1EXP int    ASN1CALL encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *);
1287 ASN1EXP size_t ASN1CALL length_TGS_REQ(const TGS_REQ *);
1288 ASN1EXP int    ASN1CALL copy_TGS_REQ  (const TGS_REQ *, TGS_REQ *);
1289 ASN1EXP void   ASN1CALL free_TGS_REQ  (TGS_REQ *);
1290
1291
1292 /*
1293 PA-ENC-TS-ENC ::= SEQUENCE {
1294   patimestamp     [0] KerberosTime,
1295   pausec          [1] krb5int32 OPTIONAL,
1296 }
1297 */
1298
1299 typedef struct PA_ENC_TS_ENC {
1300   KerberosTime patimestamp;
1301   krb5int32 *pausec;
1302 } PA_ENC_TS_ENC;
1303
1304 ASN1EXP int    ASN1CALL decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *, size_t *);
1305 ASN1EXP int    ASN1CALL encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *, size_t *);
1306 ASN1EXP size_t ASN1CALL length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *);
1307 ASN1EXP int    ASN1CALL copy_PA_ENC_TS_ENC  (const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *);
1308 ASN1EXP void   ASN1CALL free_PA_ENC_TS_ENC  (PA_ENC_TS_ENC *);
1309
1310
1311 /*
1312 PA-PAC-REQUEST ::= SEQUENCE {
1313   include-pac     [0] BOOLEAN,
1314 }
1315 */
1316
1317 typedef struct PA_PAC_REQUEST {
1318   int include_pac;
1319 } PA_PAC_REQUEST;
1320
1321 ASN1EXP int    ASN1CALL decode_PA_PAC_REQUEST(const unsigned char *, size_t, PA_PAC_REQUEST *, size_t *);
1322 ASN1EXP int    ASN1CALL encode_PA_PAC_REQUEST(unsigned char *, size_t, const PA_PAC_REQUEST *, size_t *);
1323 ASN1EXP size_t ASN1CALL length_PA_PAC_REQUEST(const PA_PAC_REQUEST *);
1324 ASN1EXP int    ASN1CALL copy_PA_PAC_REQUEST  (const PA_PAC_REQUEST *, PA_PAC_REQUEST *);
1325 ASN1EXP void   ASN1CALL free_PA_PAC_REQUEST  (PA_PAC_REQUEST *);
1326
1327
1328 /*
1329 PROV-SRV-LOCATION ::= GeneralString
1330 */
1331
1332 typedef heim_general_string PROV_SRV_LOCATION;
1333
1334 /*
1335 KDC-REP ::= SEQUENCE {
1336   pvno            [0] krb5int32,
1337   msg-type        [1] MESSAGE-TYPE,
1338   padata          [2] METHOD-DATA OPTIONAL,
1339   crealm          [3] Realm,
1340   cname           [4] PrincipalName,
1341   ticket          [5] Ticket,
1342   enc-part        [6] EncryptedData,
1343 }
1344 */
1345
1346 typedef struct KDC_REP {
1347   krb5int32 pvno;
1348   MESSAGE_TYPE msg_type;
1349   METHOD_DATA *padata;
1350   Realm crealm;
1351   PrincipalName cname;
1352   Ticket ticket;
1353   EncryptedData enc_part;
1354 } KDC_REP;
1355
1356 ASN1EXP int    ASN1CALL decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *);
1357 ASN1EXP int    ASN1CALL encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *);
1358 ASN1EXP size_t ASN1CALL length_KDC_REP(const KDC_REP *);
1359 ASN1EXP int    ASN1CALL copy_KDC_REP  (const KDC_REP *, KDC_REP *);
1360 ASN1EXP void   ASN1CALL free_KDC_REP  (KDC_REP *);
1361
1362
1363 /*
1364 AS-REP ::= [APPLICATION 11] KDC-REP
1365 */
1366
1367 typedef KDC_REP AS_REP;
1368
1369 ASN1EXP int    ASN1CALL decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *);
1370 ASN1EXP int    ASN1CALL encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *);
1371 ASN1EXP size_t ASN1CALL length_AS_REP(const AS_REP *);
1372 ASN1EXP int    ASN1CALL copy_AS_REP  (const AS_REP *, AS_REP *);
1373 ASN1EXP void   ASN1CALL free_AS_REP  (AS_REP *);
1374
1375
1376 /*
1377 TGS-REP ::= [APPLICATION 13] KDC-REP
1378 */
1379
1380 typedef KDC_REP TGS_REP;
1381
1382 ASN1EXP int    ASN1CALL decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *);
1383 ASN1EXP int    ASN1CALL encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *);
1384 ASN1EXP size_t ASN1CALL length_TGS_REP(const TGS_REP *);
1385 ASN1EXP int    ASN1CALL copy_TGS_REP  (const TGS_REP *, TGS_REP *);
1386 ASN1EXP void   ASN1CALL free_TGS_REP  (TGS_REP *);
1387
1388
1389 /*
1390 EncKDCRepPart ::= SEQUENCE {
1391   key                 [0] EncryptionKey,
1392   last-req            [1] LastReq,
1393   nonce               [2] krb5int32,
1394   key-expiration      [3] KerberosTime OPTIONAL,
1395   flags               [4] TicketFlags,
1396   authtime            [5] KerberosTime,
1397   starttime           [6] KerberosTime OPTIONAL,
1398   endtime             [7] KerberosTime,
1399   renew-till          [8] KerberosTime OPTIONAL,
1400   srealm              [9] Realm,
1401   sname               [10] PrincipalName,
1402   caddr               [11] HostAddresses OPTIONAL,
1403   encrypted-pa-data   [12] METHOD-DATA OPTIONAL,
1404 }
1405 */
1406
1407 typedef struct EncKDCRepPart {
1408   EncryptionKey key;
1409   LastReq last_req;
1410   krb5int32 nonce;
1411   KerberosTime *key_expiration;
1412   TicketFlags flags;
1413   KerberosTime authtime;
1414   KerberosTime *starttime;
1415   KerberosTime endtime;
1416   KerberosTime *renew_till;
1417   Realm srealm;
1418   PrincipalName sname;
1419   HostAddresses *caddr;
1420   METHOD_DATA *encrypted_pa_data;
1421 } EncKDCRepPart;
1422
1423 ASN1EXP int    ASN1CALL decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *, size_t *);
1424 ASN1EXP int    ASN1CALL encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *, size_t *);
1425 ASN1EXP size_t ASN1CALL length_EncKDCRepPart(const EncKDCRepPart *);
1426 ASN1EXP int    ASN1CALL copy_EncKDCRepPart  (const EncKDCRepPart *, EncKDCRepPart *);
1427 ASN1EXP void   ASN1CALL free_EncKDCRepPart  (EncKDCRepPart *);
1428
1429
1430 /*
1431 EncASRepPart ::= [APPLICATION 25] EncKDCRepPart
1432 */
1433
1434 typedef EncKDCRepPart EncASRepPart;
1435
1436 ASN1EXP int    ASN1CALL decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *, size_t *);
1437 ASN1EXP int    ASN1CALL encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *, size_t *);
1438 ASN1EXP size_t ASN1CALL length_EncASRepPart(const EncASRepPart *);
1439 ASN1EXP int    ASN1CALL copy_EncASRepPart  (const EncASRepPart *, EncASRepPart *);
1440 ASN1EXP void   ASN1CALL free_EncASRepPart  (EncASRepPart *);
1441
1442
1443 /*
1444 EncTGSRepPart ::= [APPLICATION 26] EncKDCRepPart
1445 */
1446
1447 typedef EncKDCRepPart EncTGSRepPart;
1448
1449 ASN1EXP int    ASN1CALL decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *, size_t *);
1450 ASN1EXP int    ASN1CALL encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *, size_t *);
1451 ASN1EXP size_t ASN1CALL length_EncTGSRepPart(const EncTGSRepPart *);
1452 ASN1EXP int    ASN1CALL copy_EncTGSRepPart  (const EncTGSRepPart *, EncTGSRepPart *);
1453 ASN1EXP void   ASN1CALL free_EncTGSRepPart  (EncTGSRepPart *);
1454
1455
1456 /*
1457 AP-REQ ::= [APPLICATION 14] SEQUENCE {
1458   pvno            [0] krb5int32,
1459   msg-type        [1] MESSAGE-TYPE,
1460   ap-options      [2] APOptions,
1461   ticket          [3] Ticket,
1462   authenticator   [4] EncryptedData,
1463 }
1464 */
1465
1466 typedef struct AP_REQ {
1467   krb5int32 pvno;
1468   MESSAGE_TYPE msg_type;
1469   APOptions ap_options;
1470   Ticket ticket;
1471   EncryptedData authenticator;
1472 } AP_REQ;
1473
1474 ASN1EXP int    ASN1CALL decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *);
1475 ASN1EXP int    ASN1CALL encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *);
1476 ASN1EXP size_t ASN1CALL length_AP_REQ(const AP_REQ *);
1477 ASN1EXP int    ASN1CALL copy_AP_REQ  (const AP_REQ *, AP_REQ *);
1478 ASN1EXP void   ASN1CALL free_AP_REQ  (AP_REQ *);
1479
1480
1481 /*
1482 AP-REP ::= [APPLICATION 15] SEQUENCE {
1483   pvno            [0] krb5int32,
1484   msg-type        [1] MESSAGE-TYPE,
1485   enc-part        [2] EncryptedData,
1486 }
1487 */
1488
1489 typedef struct AP_REP {
1490   krb5int32 pvno;
1491   MESSAGE_TYPE msg_type;
1492   EncryptedData enc_part;
1493 } AP_REP;
1494
1495 ASN1EXP int    ASN1CALL decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *);
1496 ASN1EXP int    ASN1CALL encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *);
1497 ASN1EXP size_t ASN1CALL length_AP_REP(const AP_REP *);
1498 ASN1EXP int    ASN1CALL copy_AP_REP  (const AP_REP *, AP_REP *);
1499 ASN1EXP void   ASN1CALL free_AP_REP  (AP_REP *);
1500
1501
1502 /*
1503 EncAPRepPart ::= [APPLICATION 27] SEQUENCE {
1504   ctime           [0] KerberosTime,
1505   cusec           [1] krb5int32,
1506   subkey          [2] EncryptionKey OPTIONAL,
1507   seq-number      [3] krb5uint32 OPTIONAL,
1508 }
1509 */
1510
1511 typedef struct EncAPRepPart {
1512   KerberosTime ctime;
1513   krb5int32 cusec;
1514   EncryptionKey *subkey;
1515   krb5uint32 *seq_number;
1516 } EncAPRepPart;
1517
1518 ASN1EXP int    ASN1CALL decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *, size_t *);
1519 ASN1EXP int    ASN1CALL encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *, size_t *);
1520 ASN1EXP size_t ASN1CALL length_EncAPRepPart(const EncAPRepPart *);
1521 ASN1EXP int    ASN1CALL copy_EncAPRepPart  (const EncAPRepPart *, EncAPRepPart *);
1522 ASN1EXP void   ASN1CALL free_EncAPRepPart  (EncAPRepPart *);
1523
1524
1525 /*
1526 KRB-SAFE-BODY ::= SEQUENCE {
1527   user-data       [0] OCTET STRING,
1528   timestamp       [1] KerberosTime OPTIONAL,
1529   usec            [2] krb5int32 OPTIONAL,
1530   seq-number      [3] krb5uint32 OPTIONAL,
1531   s-address       [4] HostAddress OPTIONAL,
1532   r-address       [5] HostAddress OPTIONAL,
1533 }
1534 */
1535
1536 typedef struct KRB_SAFE_BODY {
1537   heim_octet_string user_data;
1538   KerberosTime *timestamp;
1539   krb5int32 *usec;
1540   krb5uint32 *seq_number;
1541   HostAddress *s_address;
1542   HostAddress *r_address;
1543 } KRB_SAFE_BODY;
1544
1545 ASN1EXP int    ASN1CALL decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *, size_t *);
1546 ASN1EXP int    ASN1CALL encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *, size_t *);
1547 ASN1EXP size_t ASN1CALL length_KRB_SAFE_BODY(const KRB_SAFE_BODY *);
1548 ASN1EXP int    ASN1CALL copy_KRB_SAFE_BODY  (const KRB_SAFE_BODY *, KRB_SAFE_BODY *);
1549 ASN1EXP void   ASN1CALL free_KRB_SAFE_BODY  (KRB_SAFE_BODY *);
1550
1551
1552 /*
1553 KRB-SAFE ::= [APPLICATION 20] SEQUENCE {
1554   pvno            [0] krb5int32,
1555   msg-type        [1] MESSAGE-TYPE,
1556   safe-body       [2] KRB-SAFE-BODY,
1557   cksum           [3] Checksum,
1558 }
1559 */
1560
1561 typedef struct KRB_SAFE {
1562   krb5int32 pvno;
1563   MESSAGE_TYPE msg_type;
1564   KRB_SAFE_BODY safe_body;
1565   Checksum cksum;
1566 } KRB_SAFE;
1567
1568 ASN1EXP int    ASN1CALL decode_KRB_SAFE(const unsigned char *, size_t, KRB_SAFE *, size_t *);
1569 ASN1EXP int    ASN1CALL encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *);
1570 ASN1EXP size_t ASN1CALL length_KRB_SAFE(const KRB_SAFE *);
1571 ASN1EXP int    ASN1CALL copy_KRB_SAFE  (const KRB_SAFE *, KRB_SAFE *);
1572 ASN1EXP void   ASN1CALL free_KRB_SAFE  (KRB_SAFE *);
1573
1574
1575 /*
1576 KRB-PRIV ::= [APPLICATION 21] SEQUENCE {
1577   pvno            [0] krb5int32,
1578   msg-type        [1] MESSAGE-TYPE,
1579   enc-part        [3] EncryptedData,
1580 }
1581 */
1582
1583 typedef struct KRB_PRIV {
1584   krb5int32 pvno;
1585   MESSAGE_TYPE msg_type;
1586   EncryptedData enc_part;
1587 } KRB_PRIV;
1588
1589 ASN1EXP int    ASN1CALL decode_KRB_PRIV(const unsigned char *, size_t, KRB_PRIV *, size_t *);
1590 ASN1EXP int    ASN1CALL encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *);
1591 ASN1EXP size_t ASN1CALL length_KRB_PRIV(const KRB_PRIV *);
1592 ASN1EXP int    ASN1CALL copy_KRB_PRIV  (const KRB_PRIV *, KRB_PRIV *);
1593 ASN1EXP void   ASN1CALL free_KRB_PRIV  (KRB_PRIV *);
1594
1595
1596 /*
1597 EncKrbPrivPart ::= [APPLICATION 28] SEQUENCE {
1598   user-data       [0] OCTET STRING,
1599   timestamp       [1] KerberosTime OPTIONAL,
1600   usec            [2] krb5int32 OPTIONAL,
1601   seq-number      [3] krb5uint32 OPTIONAL,
1602   s-address       [4] HostAddress OPTIONAL,
1603   r-address       [5] HostAddress OPTIONAL,
1604 }
1605 */
1606
1607 typedef struct EncKrbPrivPart {
1608   heim_octet_string user_data;
1609   KerberosTime *timestamp;
1610   krb5int32 *usec;
1611   krb5uint32 *seq_number;
1612   HostAddress *s_address;
1613   HostAddress *r_address;
1614 } EncKrbPrivPart;
1615
1616 ASN1EXP int    ASN1CALL decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart *, size_t *);
1617 ASN1EXP int    ASN1CALL encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart *, size_t *);
1618 ASN1EXP size_t ASN1CALL length_EncKrbPrivPart(const EncKrbPrivPart *);
1619 ASN1EXP int    ASN1CALL copy_EncKrbPrivPart  (const EncKrbPrivPart *, EncKrbPrivPart *);
1620 ASN1EXP void   ASN1CALL free_EncKrbPrivPart  (EncKrbPrivPart *);
1621
1622
1623 /*
1624 KRB-CRED ::= [APPLICATION 22] SEQUENCE {
1625   pvno            [0] krb5int32,
1626   msg-type        [1] MESSAGE-TYPE,
1627   tickets         [2] SEQUENCE OF Ticket,
1628   enc-part        [3] EncryptedData,
1629 }
1630 */
1631
1632 typedef struct KRB_CRED {
1633   krb5int32 pvno;
1634   MESSAGE_TYPE msg_type;
1635   struct KRB_CRED_tickets {
1636     unsigned int len;
1637     Ticket *val;
1638   } tickets;
1639   EncryptedData enc_part;
1640 } KRB_CRED;
1641
1642 ASN1EXP int    ASN1CALL decode_KRB_CRED(const unsigned char *, size_t, KRB_CRED *, size_t *);
1643 ASN1EXP int    ASN1CALL encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *);
1644 ASN1EXP size_t ASN1CALL length_KRB_CRED(const KRB_CRED *);
1645 ASN1EXP int    ASN1CALL copy_KRB_CRED  (const KRB_CRED *, KRB_CRED *);
1646 ASN1EXP void   ASN1CALL free_KRB_CRED  (KRB_CRED *);
1647
1648
1649 /*
1650 KrbCredInfo ::= SEQUENCE {
1651   key             [0] EncryptionKey,
1652   prealm          [1] Realm OPTIONAL,
1653   pname           [2] PrincipalName OPTIONAL,
1654   flags           [3] TicketFlags OPTIONAL,
1655   authtime        [4] KerberosTime OPTIONAL,
1656   starttime       [5] KerberosTime OPTIONAL,
1657   endtime         [6] KerberosTime OPTIONAL,
1658   renew-till      [7] KerberosTime OPTIONAL,
1659   srealm          [8] Realm OPTIONAL,
1660   sname           [9] PrincipalName OPTIONAL,
1661   caddr           [10] HostAddresses OPTIONAL,
1662 }
1663 */
1664
1665 typedef struct KrbCredInfo {
1666   EncryptionKey key;
1667   Realm *prealm;
1668   PrincipalName *pname;
1669   TicketFlags *flags;
1670   KerberosTime *authtime;
1671   KerberosTime *starttime;
1672   KerberosTime *endtime;
1673   KerberosTime *renew_till;
1674   Realm *srealm;
1675   PrincipalName *sname;
1676   HostAddresses *caddr;
1677 } KrbCredInfo;
1678
1679 ASN1EXP int    ASN1CALL decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *, size_t *);
1680 ASN1EXP int    ASN1CALL encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *, size_t *);
1681 ASN1EXP size_t ASN1CALL length_KrbCredInfo(const KrbCredInfo *);
1682 ASN1EXP int    ASN1CALL copy_KrbCredInfo  (const KrbCredInfo *, KrbCredInfo *);
1683 ASN1EXP void   ASN1CALL free_KrbCredInfo  (KrbCredInfo *);
1684
1685
1686 /*
1687 EncKrbCredPart ::= [APPLICATION 29] SEQUENCE {
1688   ticket-info     [0] SEQUENCE OF KrbCredInfo,
1689   nonce           [1] krb5int32 OPTIONAL,
1690   timestamp       [2] KerberosTime OPTIONAL,
1691   usec            [3] krb5int32 OPTIONAL,
1692   s-address       [4] HostAddress OPTIONAL,
1693   r-address       [5] HostAddress OPTIONAL,
1694 }
1695 */
1696
1697 typedef struct EncKrbCredPart {
1698   struct EncKrbCredPart_ticket_info {
1699     unsigned int len;
1700     KrbCredInfo *val;
1701   } ticket_info;
1702   krb5int32 *nonce;
1703   KerberosTime *timestamp;
1704   krb5int32 *usec;
1705   HostAddress *s_address;
1706   HostAddress *r_address;
1707 } EncKrbCredPart;
1708
1709 ASN1EXP int    ASN1CALL decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart *, size_t *);
1710 ASN1EXP int    ASN1CALL encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart *, size_t *);
1711 ASN1EXP size_t ASN1CALL length_EncKrbCredPart(const EncKrbCredPart *);
1712 ASN1EXP int    ASN1CALL copy_EncKrbCredPart  (const EncKrbCredPart *, EncKrbCredPart *);
1713 ASN1EXP void   ASN1CALL free_EncKrbCredPart  (EncKrbCredPart *);
1714
1715
1716 /*
1717 KRB-ERROR ::= [APPLICATION 30] SEQUENCE {
1718   pvno            [0] krb5int32,
1719   msg-type        [1] MESSAGE-TYPE,
1720   ctime           [2] KerberosTime OPTIONAL,
1721   cusec           [3] krb5int32 OPTIONAL,
1722   stime           [4] KerberosTime,
1723   susec           [5] krb5int32,
1724   error-code      [6] krb5int32,
1725   crealm          [7] Realm OPTIONAL,
1726   cname           [8] PrincipalName OPTIONAL,
1727   realm           [9] Realm,
1728   sname           [10] PrincipalName,
1729   e-text          [11] GeneralString OPTIONAL,
1730   e-data          [12] OCTET STRING OPTIONAL,
1731 }
1732 */
1733
1734 typedef struct KRB_ERROR {
1735   krb5int32 pvno;
1736   MESSAGE_TYPE msg_type;
1737   KerberosTime *ctime;
1738   krb5int32 *cusec;
1739   KerberosTime stime;
1740   krb5int32 susec;
1741   krb5int32 error_code;
1742   Realm *crealm;
1743   PrincipalName *cname;
1744   Realm realm;
1745   PrincipalName sname;
1746   heim_general_string *e_text;
1747   heim_octet_string *e_data;
1748 } KRB_ERROR;
1749
1750 ASN1EXP int    ASN1CALL decode_KRB_ERROR(const unsigned char *, size_t, KRB_ERROR *, size_t *);
1751 ASN1EXP int    ASN1CALL encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t *);
1752 ASN1EXP size_t ASN1CALL length_KRB_ERROR(const KRB_ERROR *);
1753 ASN1EXP int    ASN1CALL copy_KRB_ERROR  (const KRB_ERROR *, KRB_ERROR *);
1754 ASN1EXP void   ASN1CALL free_KRB_ERROR  (KRB_ERROR *);
1755
1756
1757 /*
1758 ChangePasswdDataMS ::= SEQUENCE {
1759   newpasswd       [0] OCTET STRING,
1760   targname        [1] PrincipalName OPTIONAL,
1761   targrealm       [2] Realm OPTIONAL,
1762 }
1763 */
1764
1765 typedef struct ChangePasswdDataMS {
1766   heim_octet_string newpasswd;
1767   PrincipalName *targname;
1768   Realm *targrealm;
1769 } ChangePasswdDataMS;
1770
1771 ASN1EXP int    ASN1CALL decode_ChangePasswdDataMS(const unsigned char *, size_t, ChangePasswdDataMS *, size_t *);
1772 ASN1EXP int    ASN1CALL encode_ChangePasswdDataMS(unsigned char *, size_t, const ChangePasswdDataMS *, size_t *);
1773 ASN1EXP size_t ASN1CALL length_ChangePasswdDataMS(const ChangePasswdDataMS *);
1774 ASN1EXP int    ASN1CALL copy_ChangePasswdDataMS  (const ChangePasswdDataMS *, ChangePasswdDataMS *);
1775 ASN1EXP void   ASN1CALL free_ChangePasswdDataMS  (ChangePasswdDataMS *);
1776
1777
1778 /*
1779 EtypeList ::= SEQUENCE OF ENCTYPE
1780 */
1781
1782 typedef struct EtypeList {
1783   unsigned int len;
1784   ENCTYPE *val;
1785 } EtypeList;
1786
1787 ASN1EXP int    ASN1CALL decode_EtypeList(const unsigned char *, size_t, EtypeList *, size_t *);
1788 ASN1EXP int    ASN1CALL encode_EtypeList(unsigned char *, size_t, const EtypeList *, size_t *);
1789 ASN1EXP size_t ASN1CALL length_EtypeList(const EtypeList *);
1790 ASN1EXP int    ASN1CALL copy_EtypeList  (const EtypeList *, EtypeList *);
1791 ASN1EXP void   ASN1CALL free_EtypeList  (EtypeList *);
1792
1793
1794 enum { krb5_pvno = 5 };
1795
1796 enum { DOMAIN_X500_COMPRESS = 1 };
1797
1798 /*
1799 AD-IF-RELEVANT ::= AuthorizationData
1800 */
1801
1802 typedef AuthorizationData AD_IF_RELEVANT;
1803
1804 ASN1EXP int    ASN1CALL decode_AD_IF_RELEVANT(const unsigned char *, size_t, AD_IF_RELEVANT *, size_t *);
1805 ASN1EXP int    ASN1CALL encode_AD_IF_RELEVANT(unsigned char *, size_t, const AD_IF_RELEVANT *, size_t *);
1806 ASN1EXP size_t ASN1CALL length_AD_IF_RELEVANT(const AD_IF_RELEVANT *);
1807 ASN1EXP int    ASN1CALL copy_AD_IF_RELEVANT  (const AD_IF_RELEVANT *, AD_IF_RELEVANT *);
1808 ASN1EXP void   ASN1CALL free_AD_IF_RELEVANT  (AD_IF_RELEVANT *);
1809
1810
1811 /*
1812 AD-KDCIssued ::= SEQUENCE {
1813   ad-checksum     [0] Checksum,
1814   i-realm         [1] Realm OPTIONAL,
1815   i-sname         [2] PrincipalName OPTIONAL,
1816   elements        [3] AuthorizationData,
1817 }
1818 */
1819
1820 typedef struct AD_KDCIssued {
1821   Checksum ad_checksum;
1822   Realm *i_realm;
1823   PrincipalName *i_sname;
1824   AuthorizationData elements;
1825 } AD_KDCIssued;
1826
1827 ASN1EXP int    ASN1CALL decode_AD_KDCIssued(const unsigned char *, size_t, AD_KDCIssued *, size_t *);
1828 ASN1EXP int    ASN1CALL encode_AD_KDCIssued(unsigned char *, size_t, const AD_KDCIssued *, size_t *);
1829 ASN1EXP size_t ASN1CALL length_AD_KDCIssued(const AD_KDCIssued *);
1830 ASN1EXP int    ASN1CALL copy_AD_KDCIssued  (const AD_KDCIssued *, AD_KDCIssued *);
1831 ASN1EXP void   ASN1CALL free_AD_KDCIssued  (AD_KDCIssued *);
1832
1833
1834 /*
1835 AD-AND-OR ::= SEQUENCE {
1836   condition-count   [0] INTEGER,
1837   elements          [1] AuthorizationData,
1838 }
1839 */
1840
1841 typedef struct AD_AND_OR {
1842   heim_integer condition_count;
1843   AuthorizationData elements;
1844 } AD_AND_OR;
1845
1846 ASN1EXP int    ASN1CALL decode_AD_AND_OR(const unsigned char *, size_t, AD_AND_OR *, size_t *);
1847 ASN1EXP int    ASN1CALL encode_AD_AND_OR(unsigned char *, size_t, const AD_AND_OR *, size_t *);
1848 ASN1EXP size_t ASN1CALL length_AD_AND_OR(const AD_AND_OR *);
1849 ASN1EXP int    ASN1CALL copy_AD_AND_OR  (const AD_AND_OR *, AD_AND_OR *);
1850 ASN1EXP void   ASN1CALL free_AD_AND_OR  (AD_AND_OR *);
1851
1852
1853 /*
1854 AD-MANDATORY-FOR-KDC ::= AuthorizationData
1855 */
1856
1857 typedef AuthorizationData AD_MANDATORY_FOR_KDC;
1858
1859 /*
1860 PA-SAM-TYPE ::= INTEGER {
1861   PA_SAM_TYPE_ENIGMA(1),
1862   PA_SAM_TYPE_DIGI_PATH(2),
1863   PA_SAM_TYPE_SKEY_K0(3),
1864   PA_SAM_TYPE_SKEY(4),
1865   PA_SAM_TYPE_SECURID(5),
1866   PA_SAM_TYPE_CRYPTOCARD(6)
1867 }
1868 */
1869
1870 typedef enum PA_SAM_TYPE {
1871   PA_SAM_TYPE_ENIGMA = 1,
1872   PA_SAM_TYPE_DIGI_PATH = 2,
1873   PA_SAM_TYPE_SKEY_K0 = 3,
1874   PA_SAM_TYPE_SKEY = 4,
1875   PA_SAM_TYPE_SECURID = 5,
1876   PA_SAM_TYPE_CRYPTOCARD = 6
1877 } PA_SAM_TYPE;
1878
1879 /*
1880 PA-SAM-REDIRECT ::= HostAddresses
1881 */
1882
1883 typedef HostAddresses PA_SAM_REDIRECT;
1884
1885 /*
1886 SAMFlags ::= BIT STRING {
1887   use-sad-as-key(0),
1888   send-encrypted-sad(1),
1889   must-pk-encrypt-sad(2)
1890 }
1891 */
1892
1893 typedef struct SAMFlags {
1894   unsigned int use_sad_as_key:1;
1895   unsigned int send_encrypted_sad:1;
1896   unsigned int must_pk_encrypt_sad:1;
1897   unsigned int _unused3:1;
1898   unsigned int _unused4:1;
1899   unsigned int _unused5:1;
1900   unsigned int _unused6:1;
1901   unsigned int _unused7:1;
1902   unsigned int _unused8:1;
1903   unsigned int _unused9:1;
1904   unsigned int _unused10:1;
1905   unsigned int _unused11:1;
1906   unsigned int _unused12:1;
1907   unsigned int _unused13:1;
1908   unsigned int _unused14:1;
1909   unsigned int _unused15:1;
1910   unsigned int _unused16:1;
1911   unsigned int _unused17:1;
1912   unsigned int _unused18:1;
1913   unsigned int _unused19:1;
1914   unsigned int _unused20:1;
1915   unsigned int _unused21:1;
1916   unsigned int _unused22:1;
1917   unsigned int _unused23:1;
1918   unsigned int _unused24:1;
1919   unsigned int _unused25:1;
1920   unsigned int _unused26:1;
1921   unsigned int _unused27:1;
1922   unsigned int _unused28:1;
1923   unsigned int _unused29:1;
1924   unsigned int _unused30:1;
1925   unsigned int _unused31:1;
1926 } SAMFlags;
1927
1928
1929 unsigned SAMFlags2int(SAMFlags);
1930 SAMFlags int2SAMFlags(unsigned);
1931 /*
1932 PA-SAM-CHALLENGE-2-BODY ::= SEQUENCE {
1933   sam-type              [0] krb5int32,
1934   sam-flags             [1] SAMFlags,
1935   sam-type-name         [2] GeneralString OPTIONAL,
1936   sam-track-id          [3] GeneralString OPTIONAL,
1937   sam-challenge-label   [4] GeneralString OPTIONAL,
1938   sam-challenge         [5] GeneralString OPTIONAL,
1939   sam-response-prompt   [6] GeneralString OPTIONAL,
1940   sam-pk-for-sad        [7] EncryptionKey OPTIONAL,
1941   sam-nonce             [8] krb5int32,
1942   sam-etype             [9] krb5int32,
1943   ...,
1944 }
1945 */
1946
1947 typedef struct PA_SAM_CHALLENGE_2_BODY {
1948   krb5int32 sam_type;
1949   SAMFlags sam_flags;
1950   heim_general_string *sam_type_name;
1951   heim_general_string *sam_track_id;
1952   heim_general_string *sam_challenge_label;
1953   heim_general_string *sam_challenge;
1954   heim_general_string *sam_response_prompt;
1955   EncryptionKey *sam_pk_for_sad;
1956   krb5int32 sam_nonce;
1957   krb5int32 sam_etype;
1958 } PA_SAM_CHALLENGE_2_BODY;
1959
1960 /*
1961 PA-SAM-CHALLENGE-2 ::= SEQUENCE {
1962   sam-body        [0] PA-SAM-CHALLENGE-2-BODY,
1963   sam-cksum       [1] SEQUENCE OF Checksum,
1964   ...,
1965 }
1966 */
1967
1968 typedef struct PA_SAM_CHALLENGE_2 {
1969   PA_SAM_CHALLENGE_2_BODY sam_body;
1970   struct PA_SAM_CHALLENGE_2_sam_cksum {
1971     unsigned int len;
1972     Checksum *val;
1973   } sam_cksum;
1974 } PA_SAM_CHALLENGE_2;
1975
1976 /*
1977 PA-SAM-RESPONSE-2 ::= SEQUENCE {
1978   sam-type               [0] krb5int32,
1979   sam-flags              [1] SAMFlags,
1980   sam-track-id           [2] GeneralString OPTIONAL,
1981   sam-enc-nonce-or-sad   [3] EncryptedData,
1982   sam-nonce              [4] krb5int32,
1983   ...,
1984 }
1985 */
1986
1987 typedef struct PA_SAM_RESPONSE_2 {
1988   krb5int32 sam_type;
1989   SAMFlags sam_flags;
1990   heim_general_string *sam_track_id;
1991   EncryptedData sam_enc_nonce_or_sad;
1992   krb5int32 sam_nonce;
1993 } PA_SAM_RESPONSE_2;
1994
1995 /*
1996 PA-ENC-SAM-RESPONSE-ENC ::= SEQUENCE {
1997   sam-nonce       [0] krb5int32,
1998   sam-sad         [1] GeneralString OPTIONAL,
1999   ...,
2000 }
2001 */
2002
2003 typedef struct PA_ENC_SAM_RESPONSE_ENC {
2004   krb5int32 sam_nonce;
2005   heim_general_string *sam_sad;
2006 } PA_ENC_SAM_RESPONSE_ENC;
2007
2008 /*
2009 PA-S4U2Self ::= SEQUENCE {
2010   name            [0] PrincipalName,
2011   realm           [1] Realm,
2012   cksum           [2] Checksum,
2013   auth            [3] GeneralString,
2014 }
2015 */
2016
2017 typedef struct PA_S4U2Self {
2018   PrincipalName name;
2019   Realm realm;
2020   Checksum cksum;
2021   heim_general_string auth;
2022 } PA_S4U2Self;
2023
2024 ASN1EXP int    ASN1CALL decode_PA_S4U2Self(const unsigned char *, size_t, PA_S4U2Self *, size_t *);
2025 ASN1EXP int    ASN1CALL encode_PA_S4U2Self(unsigned char *, size_t, const PA_S4U2Self *, size_t *);
2026 ASN1EXP size_t ASN1CALL length_PA_S4U2Self(const PA_S4U2Self *);
2027 ASN1EXP int    ASN1CALL copy_PA_S4U2Self  (const PA_S4U2Self *, PA_S4U2Self *);
2028 ASN1EXP void   ASN1CALL free_PA_S4U2Self  (PA_S4U2Self *);
2029
2030
2031 /*
2032 KRB5SignedPathData ::= SEQUENCE {
2033   client          [0] Principal OPTIONAL,
2034   authtime        [1] KerberosTime,
2035   delegated       [2] Principals OPTIONAL,
2036   method_data     [3] METHOD-DATA OPTIONAL,
2037 }
2038 */
2039
2040 typedef struct KRB5SignedPathData {
2041   Principal *client;
2042   KerberosTime authtime;
2043   Principals *delegated;
2044   METHOD_DATA *method_data;
2045 } KRB5SignedPathData;
2046
2047 ASN1EXP int    ASN1CALL decode_KRB5SignedPathData(const unsigned char *, size_t, KRB5SignedPathData *, size_t *);
2048 ASN1EXP int    ASN1CALL encode_KRB5SignedPathData(unsigned char *, size_t, const KRB5SignedPathData *, size_t *);
2049 ASN1EXP size_t ASN1CALL length_KRB5SignedPathData(const KRB5SignedPathData *);
2050 ASN1EXP int    ASN1CALL copy_KRB5SignedPathData  (const KRB5SignedPathData *, KRB5SignedPathData *);
2051 ASN1EXP void   ASN1CALL free_KRB5SignedPathData  (KRB5SignedPathData *);
2052
2053
2054 /*
2055 KRB5SignedPath ::= SEQUENCE {
2056   etype           [0] ENCTYPE,
2057   cksum           [1] Checksum,
2058   delegated       [2] Principals OPTIONAL,
2059   method_data     [3] METHOD-DATA OPTIONAL,
2060 }
2061 */
2062
2063 typedef struct KRB5SignedPath {
2064   ENCTYPE etype;
2065   Checksum cksum;
2066   Principals *delegated;
2067   METHOD_DATA *method_data;
2068 } KRB5SignedPath;
2069
2070 ASN1EXP int    ASN1CALL decode_KRB5SignedPath(const unsigned char *, size_t, KRB5SignedPath *, size_t *);
2071 ASN1EXP int    ASN1CALL encode_KRB5SignedPath(unsigned char *, size_t, const KRB5SignedPath *, size_t *);
2072 ASN1EXP size_t ASN1CALL length_KRB5SignedPath(const KRB5SignedPath *);
2073 ASN1EXP int    ASN1CALL copy_KRB5SignedPath  (const KRB5SignedPath *, KRB5SignedPath *);
2074 ASN1EXP void   ASN1CALL free_KRB5SignedPath  (KRB5SignedPath *);
2075
2076
2077 /*
2078 AD-LoginAlias ::= SEQUENCE {
2079   login-alias     [0] PrincipalName,
2080   checksum        [1] Checksum,
2081 }
2082 */
2083
2084 typedef struct AD_LoginAlias {
2085   PrincipalName login_alias;
2086   Checksum checksum;
2087 } AD_LoginAlias;
2088
2089 ASN1EXP int    ASN1CALL decode_AD_LoginAlias(const unsigned char *, size_t, AD_LoginAlias *, size_t *);
2090 ASN1EXP int    ASN1CALL encode_AD_LoginAlias(unsigned char *, size_t, const AD_LoginAlias *, size_t *);
2091 ASN1EXP size_t ASN1CALL length_AD_LoginAlias(const AD_LoginAlias *);
2092 ASN1EXP int    ASN1CALL copy_AD_LoginAlias  (const AD_LoginAlias *, AD_LoginAlias *);
2093 ASN1EXP void   ASN1CALL free_AD_LoginAlias  (AD_LoginAlias *);
2094
2095
2096 /*
2097 PA-SvrReferralData ::= SEQUENCE {
2098   referred-name    [1] PrincipalName OPTIONAL,
2099   referred-realm   [0] Realm,
2100 }
2101 */
2102
2103 typedef struct PA_SvrReferralData {
2104   PrincipalName *referred_name;
2105   Realm referred_realm;
2106 } PA_SvrReferralData;
2107
2108 ASN1EXP int    ASN1CALL decode_PA_SvrReferralData(const unsigned char *, size_t, PA_SvrReferralData *, size_t *);
2109 ASN1EXP int    ASN1CALL encode_PA_SvrReferralData(unsigned char *, size_t, const PA_SvrReferralData *, size_t *);
2110 ASN1EXP size_t ASN1CALL length_PA_SvrReferralData(const PA_SvrReferralData *);
2111 ASN1EXP int    ASN1CALL copy_PA_SvrReferralData  (const PA_SvrReferralData *, PA_SvrReferralData *);
2112 ASN1EXP void   ASN1CALL free_PA_SvrReferralData  (PA_SvrReferralData *);
2113
2114
2115 /*
2116 PA-SERVER-REFERRAL-DATA ::= EncryptedData
2117 */
2118
2119 typedef EncryptedData PA_SERVER_REFERRAL_DATA;
2120
2121 ASN1EXP int    ASN1CALL decode_PA_SERVER_REFERRAL_DATA(const unsigned char *, size_t, PA_SERVER_REFERRAL_DATA *, size_t *);
2122 ASN1EXP int    ASN1CALL encode_PA_SERVER_REFERRAL_DATA(unsigned char *, size_t, const PA_SERVER_REFERRAL_DATA *, size_t *);
2123 ASN1EXP size_t ASN1CALL length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *);
2124 ASN1EXP int    ASN1CALL copy_PA_SERVER_REFERRAL_DATA  (const PA_SERVER_REFERRAL_DATA *, PA_SERVER_REFERRAL_DATA *);
2125 ASN1EXP void   ASN1CALL free_PA_SERVER_REFERRAL_DATA  (PA_SERVER_REFERRAL_DATA *);
2126
2127
2128 /*
2129 PA-ServerReferralData ::= SEQUENCE {
2130   referred-realm             [0] Realm OPTIONAL,
2131   true-principal-name        [1] PrincipalName OPTIONAL,
2132   requested-principal-name   [2] PrincipalName OPTIONAL,
2133   referral-valid-until       [3] KerberosTime OPTIONAL,
2134   ...,
2135 }
2136 */
2137
2138 typedef struct PA_ServerReferralData {
2139   Realm *referred_realm;
2140   PrincipalName *true_principal_name;
2141   PrincipalName *requested_principal_name;
2142   KerberosTime *referral_valid_until;
2143 } PA_ServerReferralData;
2144
2145 ASN1EXP int    ASN1CALL decode_PA_ServerReferralData(const unsigned char *, size_t, PA_ServerReferralData *, size_t *);
2146 ASN1EXP int    ASN1CALL encode_PA_ServerReferralData(unsigned char *, size_t, const PA_ServerReferralData *, size_t *);
2147 ASN1EXP size_t ASN1CALL length_PA_ServerReferralData(const PA_ServerReferralData *);
2148 ASN1EXP int    ASN1CALL copy_PA_ServerReferralData  (const PA_ServerReferralData *, PA_ServerReferralData *);
2149 ASN1EXP void   ASN1CALL free_PA_ServerReferralData  (PA_ServerReferralData *);
2150
2151
2152 /*
2153 FastOptions ::= BIT STRING {
2154   reserved(0),
2155   hide-client-names(1),
2156   kdc-follow-referrals(16)
2157 }
2158 */
2159
2160 typedef struct FastOptions {
2161   unsigned int reserved:1;
2162   unsigned int hide_client_names:1;
2163   unsigned int _unused2:1;
2164   unsigned int _unused3:1;
2165   unsigned int _unused4:1;
2166   unsigned int _unused5:1;
2167   unsigned int _unused6:1;
2168   unsigned int _unused7:1;
2169   unsigned int _unused8:1;
2170   unsigned int _unused9:1;
2171   unsigned int _unused10:1;
2172   unsigned int _unused11:1;
2173   unsigned int _unused12:1;
2174   unsigned int _unused13:1;
2175   unsigned int _unused14:1;
2176   unsigned int _unused15:1;
2177   unsigned int kdc_follow_referrals:1;
2178   unsigned int _unused17:1;
2179   unsigned int _unused18:1;
2180   unsigned int _unused19:1;
2181   unsigned int _unused20:1;
2182   unsigned int _unused21:1;
2183   unsigned int _unused22:1;
2184   unsigned int _unused23:1;
2185   unsigned int _unused24:1;
2186   unsigned int _unused25:1;
2187   unsigned int _unused26:1;
2188   unsigned int _unused27:1;
2189   unsigned int _unused28:1;
2190   unsigned int _unused29:1;
2191   unsigned int _unused30:1;
2192   unsigned int _unused31:1;
2193 } FastOptions;
2194
2195
2196 unsigned FastOptions2int(FastOptions);
2197 FastOptions int2FastOptions(unsigned);
2198 /*
2199 KrbFastReq ::= SEQUENCE {
2200   fast-options    [0] FastOptions,
2201   padata          [1] METHOD-DATA,
2202   req-body        [2] KDC-REQ-BODY,
2203   ...,
2204 }
2205 */
2206
2207 typedef struct KrbFastReq {
2208   FastOptions fast_options;
2209   METHOD_DATA padata;
2210   KDC_REQ_BODY req_body;
2211 } KrbFastReq;
2212
2213 ASN1EXP int    ASN1CALL decode_KrbFastReq(const unsigned char *, size_t, KrbFastReq *, size_t *);
2214 ASN1EXP int    ASN1CALL encode_KrbFastReq(unsigned char *, size_t, const KrbFastReq *, size_t *);
2215 ASN1EXP size_t ASN1CALL length_KrbFastReq(const KrbFastReq *);
2216 ASN1EXP int    ASN1CALL copy_KrbFastReq  (const KrbFastReq *, KrbFastReq *);
2217 ASN1EXP void   ASN1CALL free_KrbFastReq  (KrbFastReq *);
2218
2219
2220 /*
2221 KrbFastArmor ::= SEQUENCE {
2222   armor-type      [0] krb5int32,
2223   armor-value     [1] OCTET STRING,
2224   ...,
2225 }
2226 */
2227
2228 typedef struct KrbFastArmor {
2229   krb5int32 armor_type;
2230   heim_octet_string armor_value;
2231 } KrbFastArmor;
2232
2233 ASN1EXP int    ASN1CALL decode_KrbFastArmor(const unsigned char *, size_t, KrbFastArmor *, size_t *);
2234 ASN1EXP int    ASN1CALL encode_KrbFastArmor(unsigned char *, size_t, const KrbFastArmor *, size_t *);
2235 ASN1EXP size_t ASN1CALL length_KrbFastArmor(const KrbFastArmor *);
2236 ASN1EXP int    ASN1CALL copy_KrbFastArmor  (const KrbFastArmor *, KrbFastArmor *);
2237 ASN1EXP void   ASN1CALL free_KrbFastArmor  (KrbFastArmor *);
2238
2239
2240 /*
2241 KrbFastArmoredReq ::= SEQUENCE {
2242   armor           [0] KrbFastArmor OPTIONAL,
2243   req-checksum    [1] Checksum,
2244   enc-fast-req    [2] EncryptedData,
2245 }
2246 */
2247
2248 typedef struct KrbFastArmoredReq {
2249   KrbFastArmor *armor;
2250   Checksum req_checksum;
2251   EncryptedData enc_fast_req;
2252 } KrbFastArmoredReq;
2253
2254 /*
2255 PA-FX-FAST-REQUEST ::= CHOICE {
2256   armored-data    [0] KrbFastArmoredReq,
2257   ...,
2258 }
2259 */
2260
2261 typedef struct PA_FX_FAST_REQUEST {
2262   enum PA_FX_FAST_REQUEST_enum {
2263     choice_PA_FX_FAST_REQUEST_asn1_ellipsis = 0,
2264     choice_PA_FX_FAST_REQUEST_armored_data
2265     /* ... */
2266   } element;
2267   union {
2268     KrbFastArmoredReq armored_data;
2269     heim_octet_string asn1_ellipsis;
2270   } u;
2271 } PA_FX_FAST_REQUEST;
2272
2273 ASN1EXP int    ASN1CALL decode_PA_FX_FAST_REQUEST(const unsigned char *, size_t, PA_FX_FAST_REQUEST *, size_t *);
2274 ASN1EXP int    ASN1CALL encode_PA_FX_FAST_REQUEST(unsigned char *, size_t, const PA_FX_FAST_REQUEST *, size_t *);
2275 ASN1EXP size_t ASN1CALL length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *);
2276 ASN1EXP int    ASN1CALL copy_PA_FX_FAST_REQUEST  (const PA_FX_FAST_REQUEST *, PA_FX_FAST_REQUEST *);
2277 ASN1EXP void   ASN1CALL free_PA_FX_FAST_REQUEST  (PA_FX_FAST_REQUEST *);
2278
2279
2280 /*
2281 KrbFastFinished ::= SEQUENCE {
2282   timestamp         [0] KerberosTime,
2283   usec              [1] krb5int32,
2284   crealm            [2] Realm,
2285   cname             [3] PrincipalName,
2286   ticket-checksum   [4] Checksum,
2287   ...,
2288 }
2289 */
2290
2291 typedef struct KrbFastFinished {
2292   KerberosTime timestamp;
2293   krb5int32 usec;
2294   Realm crealm;
2295   PrincipalName cname;
2296   Checksum ticket_checksum;
2297 } KrbFastFinished;
2298
2299 ASN1EXP int    ASN1CALL decode_KrbFastFinished(const unsigned char *, size_t, KrbFastFinished *, size_t *);
2300 ASN1EXP int    ASN1CALL encode_KrbFastFinished(unsigned char *, size_t, const KrbFastFinished *, size_t *);
2301 ASN1EXP size_t ASN1CALL length_KrbFastFinished(const KrbFastFinished *);
2302 ASN1EXP int    ASN1CALL copy_KrbFastFinished  (const KrbFastFinished *, KrbFastFinished *);
2303 ASN1EXP void   ASN1CALL free_KrbFastFinished  (KrbFastFinished *);
2304
2305
2306 /*
2307 KrbFastResponse ::= SEQUENCE {
2308   padata           [0] METHOD-DATA,
2309   strengthen-key   [1] EncryptionKey OPTIONAL,
2310   finished         [2] KrbFastFinished OPTIONAL,
2311   nonce            [3] krb5uint32,
2312   ...,
2313 }
2314 */
2315
2316 typedef struct KrbFastResponse {
2317   METHOD_DATA padata;
2318   EncryptionKey *strengthen_key;
2319   KrbFastFinished *finished;
2320   krb5uint32 nonce;
2321 } KrbFastResponse;
2322
2323 ASN1EXP int    ASN1CALL decode_KrbFastResponse(const unsigned char *, size_t, KrbFastResponse *, size_t *);
2324 ASN1EXP int    ASN1CALL encode_KrbFastResponse(unsigned char *, size_t, const KrbFastResponse *, size_t *);
2325 ASN1EXP size_t ASN1CALL length_KrbFastResponse(const KrbFastResponse *);
2326 ASN1EXP int    ASN1CALL copy_KrbFastResponse  (const KrbFastResponse *, KrbFastResponse *);
2327 ASN1EXP void   ASN1CALL free_KrbFastResponse  (KrbFastResponse *);
2328
2329
2330 /*
2331 KrbFastArmoredRep ::= SEQUENCE {
2332   enc-fast-rep    [0] EncryptedData,
2333   ...,
2334 }
2335 */
2336
2337 typedef struct KrbFastArmoredRep {
2338   EncryptedData enc_fast_rep;
2339 } KrbFastArmoredRep;
2340
2341 /*
2342 PA-FX-FAST-REPLY ::= CHOICE {
2343   armored-data    [0] KrbFastArmoredRep,
2344   ...,
2345 }
2346 */
2347
2348 typedef struct PA_FX_FAST_REPLY {
2349   enum PA_FX_FAST_REPLY_enum {
2350     choice_PA_FX_FAST_REPLY_asn1_ellipsis = 0,
2351     choice_PA_FX_FAST_REPLY_armored_data
2352     /* ... */
2353   } element;
2354   union {
2355     KrbFastArmoredRep armored_data;
2356     heim_octet_string asn1_ellipsis;
2357   } u;
2358 } PA_FX_FAST_REPLY;
2359
2360 ASN1EXP int    ASN1CALL decode_PA_FX_FAST_REPLY(const unsigned char *, size_t, PA_FX_FAST_REPLY *, size_t *);
2361 ASN1EXP int    ASN1CALL encode_PA_FX_FAST_REPLY(unsigned char *, size_t, const PA_FX_FAST_REPLY *, size_t *);
2362 ASN1EXP size_t ASN1CALL length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *);
2363 ASN1EXP int    ASN1CALL copy_PA_FX_FAST_REPLY  (const PA_FX_FAST_REPLY *, PA_FX_FAST_REPLY *);
2364 ASN1EXP void   ASN1CALL free_PA_FX_FAST_REPLY  (PA_FX_FAST_REPLY *);
2365
2366
2367 /*
2368 KDCFastFlags ::= BIT STRING {
2369   use_reply_key(0),
2370   reply_key_used(1),
2371   reply_key_replaced(2),
2372   kdc_verfied(3)
2373 }
2374 */
2375
2376 typedef struct KDCFastFlags {
2377   unsigned int use_reply_key:1;
2378   unsigned int reply_key_used:1;
2379   unsigned int reply_key_replaced:1;
2380   unsigned int kdc_verfied:1;
2381   unsigned int _unused4:1;
2382   unsigned int _unused5:1;
2383   unsigned int _unused6:1;
2384   unsigned int _unused7:1;
2385   unsigned int _unused8:1;
2386   unsigned int _unused9:1;
2387   unsigned int _unused10:1;
2388   unsigned int _unused11:1;
2389   unsigned int _unused12:1;
2390   unsigned int _unused13:1;
2391   unsigned int _unused14:1;
2392   unsigned int _unused15:1;
2393   unsigned int _unused16:1;
2394   unsigned int _unused17:1;
2395   unsigned int _unused18:1;
2396   unsigned int _unused19:1;
2397   unsigned int _unused20:1;
2398   unsigned int _unused21:1;
2399   unsigned int _unused22:1;
2400   unsigned int _unused23:1;
2401   unsigned int _unused24:1;
2402   unsigned int _unused25:1;
2403   unsigned int _unused26:1;
2404   unsigned int _unused27:1;
2405   unsigned int _unused28:1;
2406   unsigned int _unused29:1;
2407   unsigned int _unused30:1;
2408   unsigned int _unused31:1;
2409 } KDCFastFlags;
2410
2411
2412 unsigned KDCFastFlags2int(KDCFastFlags);
2413 KDCFastFlags int2KDCFastFlags(unsigned);
2414 /*
2415 KDCFastState ::= SEQUENCE {
2416   flags               [0] KDCFastFlags,
2417   expiration          [1] GeneralizedTime,
2418   fast-state          [2] METHOD-DATA,
2419   expected-pa-types   [3] SEQUENCE OF PADATA-TYPE OPTIONAL,
2420 }
2421 */
2422
2423 typedef struct KDCFastState {
2424   KDCFastFlags flags;
2425   time_t expiration;
2426   METHOD_DATA fast_state;
2427   struct KDCFastState_expected_pa_types {
2428     unsigned int len;
2429     PADATA_TYPE *val;
2430   } *expected_pa_types;
2431 } KDCFastState;
2432
2433 ASN1EXP int    ASN1CALL decode_KDCFastState(const unsigned char *, size_t, KDCFastState *, size_t *);
2434 ASN1EXP int    ASN1CALL encode_KDCFastState(unsigned char *, size_t, const KDCFastState *, size_t *);
2435 ASN1EXP size_t ASN1CALL length_KDCFastState(const KDCFastState *);
2436 ASN1EXP int    ASN1CALL copy_KDCFastState  (const KDCFastState *, KDCFastState *);
2437 ASN1EXP void   ASN1CALL free_KDCFastState  (KDCFastState *);
2438
2439
2440 /*
2441 KDCFastCookie ::= SEQUENCE {
2442   version         [0]   UTF8String,
2443   cookie          [1] EncryptedData,
2444 }
2445 */
2446
2447 typedef struct KDCFastCookie {
2448   heim_utf8_string version;
2449   EncryptedData cookie;
2450 } KDCFastCookie;
2451
2452 ASN1EXP int    ASN1CALL decode_KDCFastCookie(const unsigned char *, size_t, KDCFastCookie *, size_t *);
2453 ASN1EXP int    ASN1CALL encode_KDCFastCookie(unsigned char *, size_t, const KDCFastCookie *, size_t *);
2454 ASN1EXP size_t ASN1CALL length_KDCFastCookie(const KDCFastCookie *);
2455 ASN1EXP int    ASN1CALL copy_KDCFastCookie  (const KDCFastCookie *, KDCFastCookie *);
2456 ASN1EXP void   ASN1CALL free_KDCFastCookie  (KDCFastCookie *);
2457
2458
2459 /*
2460 KDC-PROXY-MESSAGE ::= SEQUENCE {
2461   kerb-message     [0] OCTET STRING,
2462   target-domain    [1] Realm OPTIONAL,
2463   dclocator-hint   [2] INTEGER OPTIONAL,
2464 }
2465 */
2466
2467 typedef struct KDC_PROXY_MESSAGE {
2468   heim_octet_string kerb_message;
2469   Realm *target_domain;
2470   heim_integer *dclocator_hint;
2471 } KDC_PROXY_MESSAGE;
2472
2473 ASN1EXP int    ASN1CALL decode_KDC_PROXY_MESSAGE(const unsigned char *, size_t, KDC_PROXY_MESSAGE *, size_t *);
2474 ASN1EXP int    ASN1CALL encode_KDC_PROXY_MESSAGE(unsigned char *, size_t, const KDC_PROXY_MESSAGE *, size_t *);
2475 ASN1EXP size_t ASN1CALL length_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *);
2476 ASN1EXP int    ASN1CALL copy_KDC_PROXY_MESSAGE  (const KDC_PROXY_MESSAGE *, KDC_PROXY_MESSAGE *);
2477 ASN1EXP void   ASN1CALL free_KDC_PROXY_MESSAGE  (KDC_PROXY_MESSAGE *);
2478
2479
2480 /*
2481 KERB-TIMES ::= SEQUENCE {
2482   authtime        [0] KerberosTime,
2483   starttime       [1] KerberosTime,
2484   endtime         [2] KerberosTime,
2485   renew_till      [3] KerberosTime,
2486 }
2487 */
2488
2489 typedef struct KERB_TIMES {
2490   KerberosTime authtime;
2491   KerberosTime starttime;
2492   KerberosTime endtime;
2493   KerberosTime renew_till;
2494 } KERB_TIMES;
2495
2496 ASN1EXP int    ASN1CALL decode_KERB_TIMES(const unsigned char *, size_t, KERB_TIMES *, size_t *);
2497 ASN1EXP int    ASN1CALL encode_KERB_TIMES(unsigned char *, size_t, const KERB_TIMES *, size_t *);
2498 ASN1EXP size_t ASN1CALL length_KERB_TIMES(const KERB_TIMES *);
2499 ASN1EXP int    ASN1CALL copy_KERB_TIMES  (const KERB_TIMES *, KERB_TIMES *);
2500 ASN1EXP void   ASN1CALL free_KERB_TIMES  (KERB_TIMES *);
2501
2502
2503 /*
2504 KERB-CRED ::= SEQUENCE {
2505   client          [0] Principal,
2506   server          [1] Principal,
2507   keyblock        [2] EncryptionKey,
2508   times           [3] KERB-TIMES,
2509   ticket          [4] OCTET STRING,
2510   authdata        [5] OCTET STRING,
2511   addresses       [6] HostAddresses,
2512   flags           [7] TicketFlags,
2513 }
2514 */
2515
2516 typedef struct KERB_CRED {
2517   Principal client;
2518   Principal server;
2519   EncryptionKey keyblock;
2520   KERB_TIMES times;
2521   heim_octet_string ticket;
2522   heim_octet_string authdata;
2523   HostAddresses addresses;
2524   TicketFlags flags;
2525 } KERB_CRED;
2526
2527 ASN1EXP int    ASN1CALL decode_KERB_CRED(const unsigned char *, size_t, KERB_CRED *, size_t *);
2528 ASN1EXP int    ASN1CALL encode_KERB_CRED(unsigned char *, size_t, const KERB_CRED *, size_t *);
2529 ASN1EXP size_t ASN1CALL length_KERB_CRED(const KERB_CRED *);
2530 ASN1EXP int    ASN1CALL copy_KERB_CRED  (const KERB_CRED *, KERB_CRED *);
2531 ASN1EXP void   ASN1CALL free_KERB_CRED  (KERB_CRED *);
2532
2533
2534 /*
2535 KERB-TGS-REQ-IN ::= SEQUENCE {
2536   cache           [0] OCTET STRING,
2537   addrs           [1] HostAddresses,
2538   flags           [2] krb5uint32,
2539   imp             [3] Principal OPTIONAL,
2540   ticket          [4] OCTET STRING OPTIONAL,
2541   in_cred         [5] KERB-CRED,
2542   krbtgt          [6] KERB-CRED,
2543   padata          [7] METHOD-DATA,
2544 }
2545 */
2546
2547 typedef struct KERB_TGS_REQ_IN {
2548   heim_octet_string cache;
2549   HostAddresses addrs;
2550   krb5uint32 flags;
2551   Principal *imp;
2552   heim_octet_string *ticket;
2553   KERB_CRED in_cred;
2554   KERB_CRED krbtgt;
2555   METHOD_DATA padata;
2556 } KERB_TGS_REQ_IN;
2557
2558 ASN1EXP int    ASN1CALL decode_KERB_TGS_REQ_IN(const unsigned char *, size_t, KERB_TGS_REQ_IN *, size_t *);
2559 ASN1EXP int    ASN1CALL encode_KERB_TGS_REQ_IN(unsigned char *, size_t, const KERB_TGS_REQ_IN *, size_t *);
2560 ASN1EXP size_t ASN1CALL length_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *);
2561 ASN1EXP int    ASN1CALL copy_KERB_TGS_REQ_IN  (const KERB_TGS_REQ_IN *, KERB_TGS_REQ_IN *);
2562 ASN1EXP void   ASN1CALL free_KERB_TGS_REQ_IN  (KERB_TGS_REQ_IN *);
2563
2564
2565 /*
2566 KERB-TGS-REQ-OUT ::= SEQUENCE {
2567   subkey          [0] EncryptionKey OPTIONAL,
2568   t               [1] TGS-REQ,
2569 }
2570 */
2571
2572 typedef struct KERB_TGS_REQ_OUT {
2573   EncryptionKey *subkey;
2574   TGS_REQ t;
2575 } KERB_TGS_REQ_OUT;
2576
2577 ASN1EXP int    ASN1CALL decode_KERB_TGS_REQ_OUT(const unsigned char *, size_t, KERB_TGS_REQ_OUT *, size_t *);
2578 ASN1EXP int    ASN1CALL encode_KERB_TGS_REQ_OUT(unsigned char *, size_t, const KERB_TGS_REQ_OUT *, size_t *);
2579 ASN1EXP size_t ASN1CALL length_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *);
2580 ASN1EXP int    ASN1CALL copy_KERB_TGS_REQ_OUT  (const KERB_TGS_REQ_OUT *, KERB_TGS_REQ_OUT *);
2581 ASN1EXP void   ASN1CALL free_KERB_TGS_REQ_OUT  (KERB_TGS_REQ_OUT *);
2582
2583
2584 /*
2585 KERB-TGS-REP-IN ::= SEQUENCE {
2586   cache           [0] OCTET STRING,
2587   subkey          [1] EncryptionKey OPTIONAL,
2588   in_cred         [2] KERB-CRED,
2589   t               [3] TGS-REP,
2590 }
2591 */
2592
2593 typedef struct KERB_TGS_REP_IN {
2594   heim_octet_string cache;
2595   EncryptionKey *subkey;
2596   KERB_CRED in_cred;
2597   TGS_REP t;
2598 } KERB_TGS_REP_IN;
2599
2600 /*
2601 KERB-TGS-REP-OUT ::= SEQUENCE {
2602   cache           [0] OCTET STRING,
2603   cred            [1] KERB-CRED,
2604   subkey          [2] EncryptionKey,
2605 }
2606 */
2607
2608 typedef struct KERB_TGS_REP_OUT {
2609   heim_octet_string cache;
2610   KERB_CRED cred;
2611   EncryptionKey subkey;
2612 } KERB_TGS_REP_OUT;
2613
2614 /*
2615 KERB-ARMOR-SERVICE-REPLY ::= SEQUENCE {
2616   armor           [0] KrbFastArmor,
2617   armor-key       [1] EncryptionKey,
2618 }
2619 */
2620
2621 typedef struct KERB_ARMOR_SERVICE_REPLY {
2622   KrbFastArmor armor;
2623   EncryptionKey armor_key;
2624 } KERB_ARMOR_SERVICE_REPLY;
2625
2626 ASN1EXP int    ASN1CALL decode_KERB_ARMOR_SERVICE_REPLY(const unsigned char *, size_t, KERB_ARMOR_SERVICE_REPLY *, size_t *);
2627 ASN1EXP int    ASN1CALL encode_KERB_ARMOR_SERVICE_REPLY(unsigned char *, size_t, const KERB_ARMOR_SERVICE_REPLY *, size_t *);
2628 ASN1EXP size_t ASN1CALL length_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *);
2629 ASN1EXP int    ASN1CALL copy_KERB_ARMOR_SERVICE_REPLY  (const KERB_ARMOR_SERVICE_REPLY *, KERB_ARMOR_SERVICE_REPLY *);
2630 ASN1EXP void   ASN1CALL free_KERB_ARMOR_SERVICE_REPLY  (KERB_ARMOR_SERVICE_REPLY *);
2631
2632
2633 #endif /* __krb5_asn1_h__ */