src/include/k5-int.h

   1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
   2 /*
   3  * Copyright (C) 1989,1990,1991,1992,1993,1994,1995,2000,2001, 2003,2006,2007,2008,2009 by the Massachusetts Institute of Technology,
   4  * Cambridge, MA, USA.  All Rights Reserved.
   5  *
   6  * This software is being provided to you, the LICENSEE, by the
   7  * Massachusetts Institute of Technology (M.I.T.) under the following
   8  * license.  By obtaining, using and/or copying this software, you agree
   9  * that you have read, understood, and will comply with these terms and
  10  * conditions:
  11  *
  12  * Export of this software from the United States of America may
  13  * require a specific license from the United States Government.
  14  * It is the responsibility of any person or organization contemplating
  15  * export to obtain such a license before exporting.
  16  *
  17  * WITHIN THAT CONSTRAINT, permission to use, copy, modify and distribute
  18  * this software and its documentation for any purpose and without fee or
  19  * royalty is hereby granted, provided that you agree to comply with the
  20  * following copyright notice and statements, including the disclaimer, and
  21  * that the same appear on ALL copies of the software and documentation,
  22  * including modifications that you make for internal use or for
  23  * distribution:
  24  *
  25  * THIS SOFTWARE IS PROVIDED "AS IS", AND M.I.T. MAKES NO REPRESENTATIONS
  26  * OR WARRANTIES, EXPRESS OR IMPLIED.  By way of example, but not
  27  * limitation, M.I.T. MAKES NO REPRESENTATIONS OR WARRANTIES OF
  28  * MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
  29  * THE LICENSED SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY
  30  * PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
  31  *
  32  * The name of the Massachusetts Institute of Technology or M.I.T. may NOT
  33  * be used in advertising or publicity pertaining to distribution of the
  34  * software.  Title to copyright in this software and any associated
  35  * documentation shall at all times remain with M.I.T., and USER agrees to
  36  * preserve same.
  37  *
  38  * Furthermore if you modify this software you must label
  39  * your software as modified software and not distribute it in such a
  40  * fashion that it might be confused with the original M.I.T. software.
  41  */
  42
  43 /*
  44  * Copyright (C) 1998 by the FundsXpress, INC.
  45  *
  46  * All rights reserved.
  47  *
  48  * Export of this software from the United States of America may require
  49  * a specific license from the United States Government.  It is the
  50  * responsibility of any person or organization contemplating export to
  51  * obtain such a license before exporting.
  52  *
  53  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  54  * distribute this software and its documentation for any purpose and
  55  * without fee is hereby granted, provided that the above copyright
  56  * notice appear in all copies and that both that copyright notice and
  57  * this permission notice appear in supporting documentation, and that
  58  * the name of FundsXpress. not be used in advertising or publicity pertaining
  59  * to distribution of the software without specific, written prior
  60  * permission.  FundsXpress makes no representations about the suitability of
  61  * this software for any purpose.  It is provided "as is" without express
  62  * or implied warranty.
  63  *
  64  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  65  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  66  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  67  */
  68
  69 /*
  70  * This prototype for k5-int.h (Krb5 internals include file)
  71  * includes the user-visible definitions from krb5.h and then
  72  * includes other definitions that are not user-visible but are
  73  * required for compiling Kerberos internal routines.
  74  *
  75  * John Gilmore, Cygnus Support, Sat Jan 21 22:45:52 PST 1995
  76  */
  77
  78 #ifndef _KRB5_INT_H
  79 #define _KRB5_INT_H
  80
  81 #ifdef KRB5_GENERAL__
  82 #error krb5.h included before k5-int.h
  83 #endif /* KRB5_GENERAL__ */
  84
  85 #include "osconf.h"
  86
  87 #if defined(__MACH__) && defined(__APPLE__)
  88 #       include <TargetConditionals.h>
  89 #    if TARGET_RT_MAC_CFM
  90 #       error "Use KfM 4.0 SDK headers for CFM compilation."
  91 #    endif
  92 #endif
  93
  94 /*
  95  * Begin "k5-config.h"
  96  */
  97 #ifndef KRB5_CONFIG__
  98 #define KRB5_CONFIG__
  99
 100 /*
 101  * Machine-type definitions: PC Clone 386 running Microloss Windows
 102  */
 103
 104 #if defined(_MSDOS) || defined(_WIN32)
 105 #include "win-mac.h"
 106
 107 /* Kerberos Windows initialization file */
 108 #define KERBEROS_INI    "kerberos.ini"
 109 #define INI_FILES       "Files"
 110 #define INI_KRB_CCACHE  "krb5cc"        /* Location of the ccache */
 111 #define INI_KRB5_CONF   "krb5.ini"      /* Location of krb5.conf file */
 112 #define ANSI_STDIO
 113 #endif
 114
 115 #include "autoconf.h"
 116
 117 #ifndef KRB5_SYSTYPES__
 118 #define KRB5_SYSTYPES__
 119
 120 #ifdef HAVE_SYS_TYPES_H         /* From autoconf.h */
 121 #include <sys/types.h>
 122 #else /* HAVE_SYS_TYPES_H */
 123 typedef unsigned long   u_long;
 124 typedef unsigned int    u_int;
 125 typedef unsigned short  u_short;
 126 typedef unsigned char   u_char;
 127 #endif /* HAVE_SYS_TYPES_H */
 128 #endif /* KRB5_SYSTYPES__ */
 129
 130
 131 #include "k5-platform.h"
 132 /* not used in krb5.h (yet) */
 133 typedef UINT64_TYPE krb5_ui_8;
 134 typedef INT64_TYPE krb5_int64;
 135
 136
 137 #define DEFAULT_PWD_STRING1 "Enter password"
 138 #define DEFAULT_PWD_STRING2 "Re-enter password for verification"
 139
 140 #define KRB5_KDB_MAX_LIFE       (60*60*24) /* one day */
 141 #define KRB5_KDB_MAX_RLIFE      (60*60*24*7) /* one week */
 142 #define KRB5_KDB_EXPIRATION     2145830400 /* Thu Jan  1 00:00:00 2038 UTC */
 143
 144 /*
 145  * Windows requires a different api interface to each function. Here
 146  * just define it as NULL.
 147  */
 148 #ifndef KRB5_CALLCONV
 149 #define KRB5_CALLCONV
 150 #define KRB5_CALLCONV_C
 151 #endif
 152 #ifndef O_BINARY
 153 #define O_BINARY 0
 154 #endif
 155
 156 /* #define KRB5_OLD_CRYPTO is done in krb5.h */
 157
 158 #endif /* KRB5_CONFIG__ */
 159
 160 /*
 161  * End "k5-config.h"
 162  */
 163
 164 /*
 165  * After loading the configuration definitions, load the Kerberos definitions.
 166  */
 167 #include <errno.h>
 168 #include "krb5.h"
 169 #include "profile.h"
 170
 171 #include "port-sockets.h"
 172 #include "socket-utils.h"
 173
 174 /* Get mutex support; currently used only for the replay cache.  */
 175 #include "k5-thread.h"
 176
 177 /* Get error info support.  */
 178 #include "k5-err.h"
 179
 180 /* Get string buffer support. */
 181 #include "k5-buf.h"
 182
 183 /* cofiguration variables */
 184 #define KRB5_CONF_ACL_FILE                       "acl_file"
 185 #define KRB5_CONF_ADMIN_KEYTAB                   "admin_keytab"
 186 #define KRB5_CONF_ADMIN_SERVER                   "admin_server"
 187 #define KRB5_CONF_ALLOW_WEAK_CRYPTO              "allow_weak_crypto"
 188 #define KRB5_CONF_AP_REQ_CHECKSUM_TYPE           "ap_req_checksum_type"
 189 #define KRB5_CONF_AUTH_TO_LOCAL                  "auth_to_local"
 190 #define KRB5_CONF_AUTH_TO_LOCAL_NAMES            "auth_to_local_names"
 191 #define KRB5_CONF_CANONICALIZE                   "canonicalize"
 192 #define KRB5_CONF_CCACHE_TYPE                    "ccache_type"
 193 #define KRB5_CONF_CLOCKSKEW                      "clockskew"
 194 #define KRB5_CONF_DATABASE_NAME                  "database_name"
 195 #define KRB5_CONF_DB_MODULE_DIR                  "db_module_dir"
 196 #define KRB5_CONF_DB_MODULES                     "db_modules"
 197 #define KRB5_CONF_DEFAULT                        "default"
 198 #define KRB5_CONF_DEFAULT_REALM                  "default_realm"
 199 #define KRB5_CONF_DEFAULT_DOMAIN                 "default_domain"
 200 #define KRB5_CONF_DEFAULT_TKT_ENCTYPES           "default_tkt_enctypes"
 201 #define KRB5_CONF_DEFAULT_TGS_ENCTYPES           "default_tgs_enctypes"
 202 #define KRB5_CONF_DEFAULT_KEYTAB_NAME            "default_keytab_name"
 203 #define KRB5_CONF_DEFAULT_PRINCIPAL_EXPIRATION   "default_principal_expiration"
 204 #define KRB5_CONF_DEFAULT_PRINCIPAL_FLAGS        "default_principal_flags"
 205 #define KRB5_CONF_DICT_FILE                   "dict_file"
 206 #define KRB5_CONF_DNS_LOOKUP_KDC              "dns_lookup_kdc"
 207 #define KRB5_CONF_DNS_LOOKUP_REALM            "dns_lookup_realm"
 208 #define KRB5_CONF_DNS_FALLBACK                "dns_fallback"
 209 #define KRB5_CONF_DOMAIN_REALM                "domain_realm"
 210 #define KRB5_CONF_EXTRA_ADDRESSES             "extra_addresses"
 211 #define KRB5_CONF_FORWARDABLE                 "forwardable"
 212 #define KRB5_CONF_HOST_BASED_SERVICES         "host_based_services"
 213 #define KRB5_CONF_IPROP_ENABLE                "iprop_enable"
 214 #define KRB5_CONF_IPROP_MASTER_ULOGSIZE       "iprop_master_ulogsize"
 215 #define KRB5_CONF_IPROP_PORT                  "iprop_port"
 216 #define KRB5_CONF_IPROP_SLAVE_POLL            "iprop_slave_poll"
 217 #define KRB5_CONF_IPROP_LOGFILE               "iprop_logfile"
 218 #define KRB5_CONF_KADMIND_PORT                "kadmind_port"
 219 #define KRB5_CONF_KRB524_SERVER               "krb524_server"
 220 #define KRB5_CONF_KDC                         "kdc"
 221 #define KRB5_CONF_KDCDEFAULTS                 "kdcdefaults"
 222 #define KRB5_CONF_KDC_PORTS                   "kdc_ports"
 223 #define KRB5_CONF_KDC_TCP_PORTS               "kdc_tcp_ports"
 224 #define KRB5_CONF_MAX_DGRAM_REPLY_SIZE        "kdc_max_dgram_reply_size"
 225 #define KRB5_CONF_KDC_DEFAULT_OPTIONS         "kdc_default_options"
 226 #define KRB5_CONF_KDC_TIMESYNC                "kdc_timesync"
 227 #define KRB5_CONF_KDC_REQ_CHECKSUM_TYPE       "kdc_req_checksum_type"
 228 #define KRB5_CONF_KEY_STASH_FILE              "key_stash_file"
 229 #define KRB5_CONF_KPASSWD_PORT                "kpasswd_port"
 230 #define KRB5_CONF_KPASSWD_SERVER              "kpasswd_server"
 231 #define KRB5_CONF_LDAP_KDC_DN                 "ldap_kdc_dn"
 232 #define KRB5_CONF_LDAP_KADMIN_DN              "ldap_kadmind_dn"
 233 #define KRB5_CONF_LDAP_SERVICE_PASSWORD_FILE  "ldap_service_password_file"
 234 #define KRB5_CONF_LDAP_ROOT_CERTIFICATE_FILE  "ldap_root_certificate_file"
 235 #define KRB5_CONF_LDAP_SERVERS                "ldap_servers"
 236 #define KRB5_CONF_LDAP_CONNS_PER_SERVER       "ldap_conns_per_server"
 237 #define KRB5_CONF_LIBDEFAULTS                 "libdefaults"
 238 #define KRB5_CONF_LOGGING                     "logging"
 239 #define KRB5_CONF_MASTER_KEY_NAME             "master_key_name"
 240 #define KRB5_CONF_MASTER_KEY_TYPE             "master_key_type"
 241 #define KRB5_CONF_MASTER_KDC                  "master_kdc"
 242 #define KRB5_CONF_MAX_LIFE                    "max_life"
 243 #define KRB5_CONF_MAX_RENEWABLE_LIFE          "max_renewable_life"
 244 #define KRB5_CONF_NOADDRESSES                 "noaddresses"
 245 #define KRB5_CONF_NO_HOST_REFERRAL            "no_host_referral"
 246 #define KRB5_CONF_PERMITTED_ENCTYPES          "permitted_enctypes"
 247 #define KRB5_CONF_PREAUTH_MODULE_DIR          "preauth_module_dir"
 248 #define KRB5_CONF_PREFERRED_PREAUTH_TYPES     "preferred_preauth_types"
 249 #define KRB5_CONF_PROXIABLE                   "proxiable"
 250 #define KRB5_CONF_RDNS                        "rdns"
 251 #define KRB5_CONF_REALMS                      "realms"
 252 #define KRB5_CONF_REALM_TRY_DOMAINS           "realm_try_domains"
 253 #define KRB5_CONF_REJECT_BAD_TRANSIT          "reject_bad_transit"
 254 #define KRB5_CONF_RENEW_LIFETIME              "renew_lifetime"
 255 #define KRB5_CONF_SAFE_CHECKSUM_TYPE          "safe_checksum_type"
 256 #define KRB5_CONF_SUPPORTED_ENCTYPES          "supported_enctypes"
 257 #define KRB5_CONF_TICKET_LIFETIME             "ticket_lifetime"
 258 #define KRB5_CONF_UDP_PREFERENCE_LIMIT        "udp_preference_limit"
 259 #define KRB5_CONF_VERIFY_AP_REQ_NOFAIL        "verify_ap_req_nofail"
 260 #define KRB5_CONF_V4_INSTANCE_CONVERT         "v4_instance_convert"
 261 #define KRB5_CONF_V4_REALM                    "v4_realm"
 262 #define KRB5_CONF_ASTERISK                    "*"
 263 #define KRB5_CONF_FAST_AVAIL                  "fast_avail"
 264
 265 /* Error codes used in KRB_ERROR protocol messages.
 266    Return values of library routines are based on a different error table
 267    (which allows non-ambiguous error codes between subsystems) */
 268
 269 /* KDC errors */
 270 #define KDC_ERR_NONE                    0 /* No error */
 271 #define KDC_ERR_NAME_EXP                1 /* Client's entry in DB expired */
 272 #define KDC_ERR_SERVICE_EXP             2 /* Server's entry in DB expired */
 273 #define KDC_ERR_BAD_PVNO                3 /* Requested pvno not supported */
 274 #define KDC_ERR_C_OLD_MAST_KVNO         4 /* C's key encrypted in old master */
 275 #define KDC_ERR_S_OLD_MAST_KVNO         5 /* S's key encrypted in old master */
 276 #define KDC_ERR_C_PRINCIPAL_UNKNOWN     6 /* Client not found in Kerberos DB */
 277 #define KDC_ERR_S_PRINCIPAL_UNKNOWN     7 /* Server not found in Kerberos DB */
 278 #define KDC_ERR_PRINCIPAL_NOT_UNIQUE    8 /* Multiple entries in Kerberos DB */
 279 #define KDC_ERR_NULL_KEY                9 /* The C or S has a null key */
 280 #define KDC_ERR_CANNOT_POSTDATE         10 /* Tkt ineligible for postdating */
 281 #define KDC_ERR_NEVER_VALID             11 /* Requested starttime > endtime */
 282 #define KDC_ERR_POLICY                  12 /* KDC policy rejects request */
 283 #define KDC_ERR_BADOPTION               13 /* KDC can't do requested opt. */
 284 #define KDC_ERR_ENCTYPE_NOSUPP          14 /* No support for encryption type */
 285 #define KDC_ERR_SUMTYPE_NOSUPP          15 /* No support for checksum type */
 286 #define KDC_ERR_PADATA_TYPE_NOSUPP      16 /* No support for padata type */
 287 #define KDC_ERR_TRTYPE_NOSUPP           17 /* No support for transited type */
 288 #define KDC_ERR_CLIENT_REVOKED          18 /* C's creds have been revoked */
 289 #define KDC_ERR_SERVICE_REVOKED         19 /* S's creds have been revoked */
 290 #define KDC_ERR_TGT_REVOKED             20 /* TGT has been revoked */
 291 #define KDC_ERR_CLIENT_NOTYET           21 /* C not yet valid */
 292 #define KDC_ERR_SERVICE_NOTYET          22 /* S not yet valid */
 293 #define KDC_ERR_KEY_EXP                 23 /* Password has expired */
 294 #define KDC_ERR_PREAUTH_FAILED          24 /* Preauthentication failed */
 295 #define KDC_ERR_PREAUTH_REQUIRED        25 /* Additional preauthentication */
 296                                            /* required */
 297 #define KDC_ERR_SERVER_NOMATCH          26 /* Requested server and */
 298                                            /* ticket don't match*/
 299 #define KDC_ERR_MUST_USE_USER2USER      27 /* Server principal valid for */
 300                                            /*   user2user only */
 301 #define KDC_ERR_PATH_NOT_ACCEPTED       28 /* KDC policy rejected transited */
 302                                            /*   path */
 303 #define KDC_ERR_SVC_UNAVAILABLE         29 /* A service is not
 304                                             * available that is
 305                                             * required to process the
 306                                             * request */
 307 /* Application errors */
 308 #define KRB_AP_ERR_BAD_INTEGRITY 31     /* Decrypt integrity check failed */
 309 #define KRB_AP_ERR_TKT_EXPIRED  32      /* Ticket expired */
 310 #define KRB_AP_ERR_TKT_NYV      33      /* Ticket not yet valid */
 311 #define KRB_AP_ERR_REPEAT       34      /* Request is a replay */
 312 #define KRB_AP_ERR_NOT_US       35      /* The ticket isn't for us */
 313 #define KRB_AP_ERR_BADMATCH     36      /* Ticket/authenticator don't match */
 314 #define KRB_AP_ERR_SKEW         37      /* Clock skew too great */
 315 #define KRB_AP_ERR_BADADDR      38      /* Incorrect net address */
 316 #define KRB_AP_ERR_BADVERSION   39      /* Protocol version mismatch */
 317 #define KRB_AP_ERR_MSG_TYPE     40      /* Invalid message type */
 318 #define KRB_AP_ERR_MODIFIED     41      /* Message stream modified */
 319 #define KRB_AP_ERR_BADORDER     42      /* Message out of order */
 320 #define KRB_AP_ERR_BADKEYVER    44      /* Key version is not available */
 321 #define KRB_AP_ERR_NOKEY        45      /* Service key not available */
 322 #define KRB_AP_ERR_MUT_FAIL     46      /* Mutual authentication failed */
 323 #define KRB_AP_ERR_BADDIRECTION 47      /* Incorrect message direction */
 324 #define KRB_AP_ERR_METHOD       48      /* Alternative authentication */
 325                                         /* method required */
 326 #define KRB_AP_ERR_BADSEQ       49      /* Incorrect sequence numnber */
 327                                         /* in message */
 328 #define KRB_AP_ERR_INAPP_CKSUM  50      /* Inappropriate type of */
 329                                         /* checksum in message */
 330 #define KRB_AP_PATH_NOT_ACCEPTED 51     /* Policy rejects transited path */
 331 #define KRB_ERR_RESPONSE_TOO_BIG 52     /* Response too big for UDP, */
 332                                         /*   retry with TCP */
 333
 334 /* other errors */
 335 #define KRB_ERR_GENERIC         60      /* Generic error (description */
 336                                         /* in e-text) */
 337 #define KRB_ERR_FIELD_TOOLONG   61      /* Field is too long for impl. */
 338
 339 /* PKINIT server-reported errors */
 340 #define KDC_ERR_CLIENT_NOT_TRUSTED              62 /* client cert not trusted */
 341 #define KDC_ERR_KDC_NOT_TRUSTED                 63
 342 #define KDC_ERR_INVALID_SIG                     64 /* client signature verify failed */
 343 #define KDC_ERR_DH_KEY_PARAMETERS_NOT_ACCEPTED  65 /* invalid Diffie-Hellman parameters */
 344 #define KDC_ERR_CERTIFICATE_MISMATCH            66
 345 #define KRB_AP_ERR_NO_TGT                       67
 346 #define KDC_ERR_WRONG_REALM                     68
 347 #define KRB_AP_ERR_USER_TO_USER_REQUIRED        69
 348 #define KDC_ERR_CANT_VERIFY_CERTIFICATE         70 /* client cert not verifiable to */
 349                                                    /* trusted root cert */
 350 #define KDC_ERR_INVALID_CERTIFICATE             71 /* client cert had invalid signature */
 351 #define KDC_ERR_REVOKED_CERTIFICATE             72 /* client cert was revoked */
 352 #define KDC_ERR_REVOCATION_STATUS_UNKNOWN       73 /* client cert revoked, reason unknown */
 353 #define KDC_ERR_REVOCATION_STATUS_UNAVAILABLE   74
 354 #define KDC_ERR_CLIENT_NAME_MISMATCH            75 /* mismatch between client cert and */
 355                                                    /* principal name */
 356 #define KDC_ERR_INCONSISTENT_KEY_PURPOSE        77 /* bad extended key use */
 357 #define KDC_ERR_DIGEST_IN_CERT_NOT_ACCEPTED     78 /* bad digest algorithm in client cert */
 358 #define KDC_ERR_PA_CHECKSUM_MUST_BE_INCLUDED    79 /* missing paChecksum in PA-PK-AS-REQ */
 359 #define KDC_ERR_DIGEST_IN_SIGNED_DATA_NOT_ACCEPTED 80 /* bad digest algorithm in SignedData */
 360 #define KDC_ERR_PUBLIC_KEY_ENCRYPTION_NOT_SUPPORTED 81
 361
 362 /*
 363  * This structure is returned in the e-data field of the KRB-ERROR
 364  * message when the error calling for an alternative form of
 365  * authentication is returned, KRB_AP_METHOD.
 366  */
 367 typedef struct _krb5_alt_method {
 368     krb5_magic      magic;
 369     krb5_int32      method;
 370     unsigned int    length;
 371     krb5_octet      *data;
 372 } krb5_alt_method;
 373
 374 /*
 375  * A null-terminated array of this structure is returned by the KDC as
 376  * the data part of the ETYPE_INFO preauth type.  It informs the
 377  * client which encryption types are supported.
 378  * The  same data structure is used by both etype-info and etype-info2
 379  * but s2kparams must be null when encoding etype-info.
 380  */
 381 typedef struct _krb5_etype_info_entry {
 382     krb5_magic      magic;
 383     krb5_enctype    etype;
 384     unsigned int    length;
 385     krb5_octet      *salt;
 386     krb5_data s2kparams;
 387 } krb5_etype_info_entry;
 388
 389 /*
 390  *  This is essentially -1 without sign extension which can screw up
 391  *  comparisons on 64 bit machines. If the length is this value, then
 392  *  the salt data is not present. This is to distinguish between not
 393  *  being set and being of 0 length.
 394  */
 395 #define KRB5_ETYPE_NO_SALT VALID_UINT_BITS
 396
 397 typedef krb5_etype_info_entry ** krb5_etype_info;
 398
 399 /* RFC 4537 */
 400 typedef struct _krb5_etype_list {
 401     int             length;
 402     krb5_enctype    *etypes;
 403 } krb5_etype_list;
 404
 405 /*
 406  * a sam_challenge is returned for alternate preauth
 407  */
 408 /*
 409   SAMFlags ::= BIT STRING {
 410   use-sad-as-key[0],
 411   send-encrypted-sad[1],
 412   must-pk-encrypt-sad[2]
 413   }
 414 */
 415 /*
 416   PA-SAM-CHALLENGE ::= SEQUENCE {
 417   sam-type[0]                 INTEGER,
 418   sam-flags[1]                SAMFlags,
 419   sam-type-name[2]            GeneralString OPTIONAL,
 420   sam-track-id[3]             GeneralString OPTIONAL,
 421   sam-challenge-label[4]      GeneralString OPTIONAL,
 422   sam-challenge[5]            GeneralString OPTIONAL,
 423   sam-response-prompt[6]      GeneralString OPTIONAL,
 424   sam-pk-for-sad[7]           EncryptionKey OPTIONAL,
 425   sam-nonce[8]                INTEGER OPTIONAL,
 426   sam-cksum[9]                Checksum OPTIONAL
 427   }
 428 */
 429 /* sam_type values -- informational only */
 430 #define PA_SAM_TYPE_ENIGMA     1   /*  Enigma Logic */
 431 #define PA_SAM_TYPE_DIGI_PATH  2   /*  Digital Pathways */
 432 #define PA_SAM_TYPE_SKEY_K0    3   /*  S/key where  KDC has key 0 */
 433 #define PA_SAM_TYPE_SKEY       4   /*  Traditional S/Key */
 434 #define PA_SAM_TYPE_SECURID    5   /*  Security Dynamics */
 435 #define PA_SAM_TYPE_CRYPTOCARD 6   /*  CRYPTOCard */
 436 #if 1 /* XXX need to figure out who has which numbers assigned */
 437 #define PA_SAM_TYPE_ACTIVCARD_DEC  6   /*  ActivCard decimal mode */
 438 #define PA_SAM_TYPE_ACTIVCARD_HEX  7   /*  ActivCard hex mode */
 439 #define PA_SAM_TYPE_DIGI_PATH_HEX  8   /*  Digital Pathways hex mode */
 440 #endif
 441 #define PA_SAM_TYPE_EXP_BASE    128 /* experimental */
 442 #define PA_SAM_TYPE_GRAIL               (PA_SAM_TYPE_EXP_BASE+0) /* testing */
 443 #define PA_SAM_TYPE_SECURID_PREDICT     (PA_SAM_TYPE_EXP_BASE+1) /* special */
 444
 445 typedef struct _krb5_predicted_sam_response {
 446     krb5_magic      magic;
 447     krb5_keyblock   sam_key;
 448     krb5_flags      sam_flags; /* Makes key munging easier */
 449     krb5_timestamp  stime;  /* time on server, for replay detection */
 450     krb5_int32      susec;
 451     krb5_principal  client;
 452     krb5_data       msd;    /* mechanism specific data */
 453 } krb5_predicted_sam_response;
 454
 455 typedef struct _krb5_sam_challenge {
 456     krb5_magic      magic;
 457     krb5_int32      sam_type; /* information */
 458     krb5_flags      sam_flags; /* KRB5_SAM_* values */
 459     krb5_data       sam_type_name;
 460     krb5_data       sam_track_id;
 461     krb5_data       sam_challenge_label;
 462     krb5_data       sam_challenge;
 463     krb5_data       sam_response_prompt;
 464     krb5_data       sam_pk_for_sad;
 465     krb5_int32      sam_nonce;
 466     krb5_checksum   sam_cksum;
 467 } krb5_sam_challenge;
 468
 469 typedef struct _krb5_sam_key {  /* reserved for future use */
 470     krb5_magic      magic;
 471     krb5_keyblock   sam_key;
 472 } krb5_sam_key;
 473
 474 typedef struct _krb5_enc_sam_response_enc {
 475     krb5_magic      magic;
 476     krb5_int32      sam_nonce;
 477     krb5_timestamp  sam_timestamp;
 478     krb5_int32      sam_usec;
 479     krb5_data       sam_sad;
 480 } krb5_enc_sam_response_enc;
 481
 482 typedef struct _krb5_sam_response {
 483     krb5_magic      magic;
 484     krb5_int32      sam_type; /* informational */
 485     krb5_flags      sam_flags; /* KRB5_SAM_* values */
 486     krb5_data       sam_track_id; /* copied */
 487     krb5_enc_data   sam_enc_key; /* krb5_sam_key - future use */
 488     krb5_enc_data   sam_enc_nonce_or_ts; /* krb5_enc_sam_response_enc */
 489     krb5_int32      sam_nonce;
 490     krb5_timestamp  sam_patimestamp;
 491 } krb5_sam_response;
 492
 493 typedef struct _krb5_sam_challenge_2 {
 494     krb5_data       sam_challenge_2_body;
 495     krb5_checksum   **sam_cksum;            /* Array of checksums */
 496 } krb5_sam_challenge_2;
 497
 498 typedef struct _krb5_sam_challenge_2_body {
 499     krb5_magic      magic;
 500     krb5_int32      sam_type; /* information */
 501     krb5_flags      sam_flags; /* KRB5_SAM_* values */
 502     krb5_data       sam_type_name;
 503     krb5_data       sam_track_id;
 504     krb5_data       sam_challenge_label;
 505     krb5_data       sam_challenge;
 506     krb5_data       sam_response_prompt;
 507     krb5_data       sam_pk_for_sad;
 508     krb5_int32      sam_nonce;
 509     krb5_enctype    sam_etype;
 510 } krb5_sam_challenge_2_body;
 511
 512 typedef struct _krb5_sam_response_2 {
 513     krb5_magic      magic;
 514     krb5_int32      sam_type; /* informational */
 515     krb5_flags      sam_flags; /* KRB5_SAM_* values */
 516     krb5_data       sam_track_id; /* copied */
 517     krb5_enc_data   sam_enc_nonce_or_sad; /* krb5_enc_sam_response_enc */
 518     krb5_int32      sam_nonce;
 519 } krb5_sam_response_2;
 520
 521 typedef struct _krb5_enc_sam_response_enc_2 {
 522     krb5_magic      magic;
 523     krb5_int32      sam_nonce;
 524     krb5_data       sam_sad;
 525 } krb5_enc_sam_response_enc_2;
 526
 527 /*
 528  * Keep the pkinit definitions in a separate file so that the plugin
 529  * only has to include k5-int-pkinit.h rather than k5-int.h
 530  */
 531
 532 #include "k5-int-pkinit.h"
 533
 534 #include <stdlib.h>
 535 #include <string.h>
 536
 537 #ifndef HAVE_STRDUP
 538 extern char *strdup (const char *);
 539 #endif
 540
 541 #ifdef HAVE_UNISTD_H
 542 #include <unistd.h>
 543 #endif
 544
 545 #ifdef HAVE_SYS_TIME_H
 546 #include <sys/time.h>
 547 #ifdef TIME_WITH_SYS_TIME
 548 #include <time.h>
 549 #endif
 550 #else
 551 #include <time.h>
 552 #endif
 553
 554 #ifdef HAVE_SYS_STAT_H
 555 #include <sys/stat.h>                   /* struct stat, stat() */
 556 #endif
 557
 558 #ifdef HAVE_SYS_PARAM_H
 559 #include <sys/param.h>                  /* MAXPATHLEN */
 560 #endif
 561
 562 #ifdef HAVE_SYS_FILE_H
 563 #include <sys/file.h>                   /* prototypes for file-related
 564                                            syscalls; flags for open &
 565                                            friends */
 566 #endif
 567
 568 #ifdef HAVE_FCNTL_H
 569 #include <fcntl.h>
 570 #endif
 571
 572 #include <stdio.h>
 573
 574 #include "k5-gmt_mktime.h"
 575
 576 struct addrlist;
 577 struct sendto_callback_info;
 578
 579 /* libos.spec */
 580 krb5_error_code krb5_lock_file(krb5_context, int, int);
 581 krb5_error_code krb5_unlock_file(krb5_context, int);
 582 krb5_error_code krb5_sendto_kdc(krb5_context, const krb5_data *,
 583                                 const krb5_data *, krb5_data *, int *, int);
 584
 585 krb5_error_code krb5_get_krbhst(krb5_context, const krb5_data *, char *** );
 586 krb5_error_code krb5_free_krbhst(krb5_context, char * const * );
 587 krb5_error_code krb5_create_secure_file(krb5_context, const char * pathname);
 588 krb5_error_code krb5_sync_disk_file(krb5_context, FILE *fp);
 589
 590 krb5_error_code krb5int_init_context_kdc(krb5_context *);
 591
 592 krb5_error_code krb5_os_init_context(krb5_context, krb5_boolean);
 593
 594 void krb5_os_free_context(krb5_context);
 595
 596 /* This function is needed by KfM's KerberosPreferences API
 597  * because it needs to be able to specify "secure" */
 598 krb5_error_code
 599 os_get_default_config_files(profile_filespec_t **pfiles, krb5_boolean secure);
 600
 601 krb5_error_code
 602 krb5_os_hostaddr(krb5_context, const char *, krb5_address ***);
 603
 604 krb5_error_code
 605 krb5int_get_domain_realm_mapping(krb5_context , const char *, char ***);
 606
 607 /* N.B.: You need to include fake-addrinfo.h *before* k5-int.h if you're
 608    going to use this structure.  */
 609 struct addrlist {
 610     struct {
 611 #ifdef FAI_DEFINED
 612         struct addrinfo *ai;
 613 #else
 614         struct undefined_addrinfo *ai;
 615 #endif
 616         void (*freefn)(void *);
 617         void *data;
 618     } *addrs;
 619     size_t naddrs;
 620     size_t space;
 621 };
 622 #define ADDRLIST_INIT { 0, 0, 0 }
 623 extern void krb5int_free_addrlist(struct addrlist *);
 624 extern int krb5int_grow_addrlist(struct addrlist *, int);
 625 extern int krb5int_add_host_to_list(struct addrlist *, const char *,
 626                                     int, int, int, int);
 627
 628 #include <krb5/locate_plugin.h>
 629 krb5_error_code
 630 krb5int_locate_server(krb5_context, const krb5_data *realm,
 631                       struct addrlist *, enum locate_service_type svc,
 632                       int sockettype, int family);
 633
 634 struct derived_key {
 635     krb5_data constant;
 636     krb5_key dkey;
 637     struct derived_key *next;
 638 };
 639
 640 /* Internal structure of an opaque key identifier */
 641 struct krb5_key_st {
 642     krb5_keyblock keyblock;
 643     int refcount;
 644     struct derived_key *derived;
 645     /*
 646      * Cache of data private to the cipher implementation, which we
 647      * don't want to have to recompute for every operation.  This may
 648      * include key schedules, iteration counts, etc.
 649      *
 650      * The cipher implementation is responsible for setting this up
 651      * whenever needed, and the enc_provider key_cleanup method must
 652      * then be provided to dispose of it.
 653      */
 654     void *cache;
 655 };
 656
 657 /* new encryption provider api */
 658
 659 struct krb5_enc_provider {
 660     /* keybytes is the input size to make_key;
 661        keylength is the output size */
 662     size_t block_size, keybytes, keylength;
 663
 664     krb5_error_code (*encrypt)(krb5_key key, const krb5_data *cipher_state,
 665                                krb5_crypto_iov *data, size_t num_data);
 666
 667     krb5_error_code (*decrypt)(krb5_key key, const krb5_data *cipher_state,
 668                                krb5_crypto_iov *data, size_t num_data);
 669
 670     /* May be NULL if the cipher is not used for a cbc-mac checksum. */
 671     krb5_error_code (*cbc_mac)(krb5_key key, const krb5_crypto_iov *data,
 672                                size_t num_data, const krb5_data *ivec,
 673                                krb5_data *output);
 674
 675     krb5_error_code (*make_key)(const krb5_data *randombits,
 676                                 krb5_keyblock *key);
 677
 678     krb5_error_code (*init_state)(const krb5_keyblock *key,
 679                                   krb5_keyusage keyusage,
 680                                   krb5_data *out_state);
 681     krb5_error_code (*free_state)(krb5_data *state);
 682
 683     /* May be NULL if there is no key-derived data cached.  */
 684     void (*key_cleanup)(krb5_key key);
 685 };
 686
 687 struct krb5_hash_provider {
 688     char hash_name[8];
 689     size_t hashsize, blocksize;
 690
 691     krb5_error_code (*hash)(const krb5_crypto_iov *data, size_t num_data,
 692                             krb5_data *output);
 693 };
 694
 695 /*
 696  * in here to deal with stuff from lib/crypto
 697  */
 698
 699 void krb5int_nfold(unsigned int inbits, const unsigned char *in,
 700                    unsigned int outbits, unsigned char *out);
 701
 702 krb5_error_code krb5int_hmac(const struct krb5_hash_provider *hash,
 703                              krb5_key key, const krb5_crypto_iov *data,
 704                              size_t num_data, krb5_data *output);
 705
 706 krb5_error_code
 707 krb5int_hmac_keyblock(const struct krb5_hash_provider *hash,
 708                       const krb5_keyblock *keyblock,
 709                       const krb5_crypto_iov *data, size_t num_data,
 710                       krb5_data *output);
 711
 712 krb5_error_code krb5int_pbkdf2_hmac_sha1(const krb5_data *, unsigned long,
 713                                          const krb5_data *, const krb5_data *);
 714
 715 /* These crypto functions are used by GSSAPI via the accessor. */
 716
 717 krb5_error_code
 718 krb5int_arcfour_gsscrypt(const krb5_keyblock *keyblock, krb5_keyusage usage,
 719                          const krb5_data *kd_data, krb5_crypto_iov *data,
 720                          size_t num_data);
 721
 722 /*
 723  * Attempt to zero memory in a way that compilers won't optimize out.
 724  *
 725  * This mechanism should work even for heap storage about to be freed,
 726  * or automatic storage right before we return from a function.
 727  *
 728  * Then, even if we leak uninitialized memory someplace, or UNIX
 729  * "core" files get created with world-read access, some of the most
 730  * sensitive data in the process memory will already be safely wiped.
 731  *
 732  * We're not going so far -- yet -- as to try to protect key data that
 733  * may have been written into swap space....
 734  */
 735 #ifdef _WIN32
 736 # define zap(ptr, len) SecureZeroMemory(ptr, len)
 737 #elif defined(__GNUC__)
 738 static inline void zap(void *ptr, size_t len)
 739 {
 740     memset(ptr, 0, len);
 741     /*
 742      * Some versions of gcc have gotten clever enough to eliminate a
 743      * memset call right before the block in question is released.
 744      * This (empty) asm requires it to assume that we're doing
 745      * something interesting with the stored (zero) value, so the
 746      * memset can't be eliminated.
 747      *
 748      * An optimizer that looks at assembly or object code may not be
 749      * fooled, and may still cause the memset to go away.  Address
 750      * that problem if and when we encounter it.
 751      *
 752      * This also may not be enough if free() does something
 753      * interesting like purge memory locations from a write-back cache
 754      * that hasn't written back the zero bytes yet.  A memory barrier
 755      * instruction would help in that case.
 756      */
 757     asm volatile ("" : : "g" (ptr), "g" (len));
 758 }
 759 #else
 760 /* Use a function from libkrb5support to defeat inlining. */
 761 # define zap(ptr, len) krb5int_zap(ptr, len)
 762 #endif
 763
 764 /* Convenience function: zap and free ptr if it is non-NULL. */
 765 static inline void
 766 zapfree(void *ptr, size_t len)
 767 {
 768     if (ptr != NULL) {
 769         zap(ptr, len);
 770         free(ptr);
 771     }
 772 }
 773
 774 /* A definition of init_state for DES based encryption systems.
 775  * sets up an 8-byte IV of all zeros
 776  */
 777
 778 krb5_error_code
 779 krb5int_des_init_state(const krb5_keyblock *key, krb5_keyusage keyusage,
 780                        krb5_data *new_state);
 781
 782 /*
 783  * normally to free a cipher_state you can just memset the length to zero and
 784  * free it.
 785  */
 786 krb5_error_code krb5int_default_free_state(krb5_data *state);
 787
 788
 789 /*
 790  * Combine two keys (normally used by the hardware preauth mechanism)
 791  */
 792 krb5_error_code
 793 krb5int_c_combine_keys(krb5_context context, krb5_keyblock *key1,
 794                        krb5_keyblock *key2, krb5_keyblock *outkey);
 795
 796 void krb5int_c_free_keyblock(krb5_context, krb5_keyblock *key);
 797 void krb5int_c_free_keyblock_contents(krb5_context, krb5_keyblock *);
 798 krb5_error_code krb5int_c_init_keyblock(krb5_context, krb5_enctype enctype,
 799                                         size_t length, krb5_keyblock **out);
 800 krb5_error_code krb5int_c_copy_keyblock(krb5_context context,
 801                                         const krb5_keyblock *from,
 802                                         krb5_keyblock **to);
 803 krb5_error_code krb5int_c_copy_keyblock_contents(krb5_context context,
 804                                                  const krb5_keyblock *from,
 805                                                  krb5_keyblock *to);
 806
 807 /*
 808  * Internal - for cleanup.
 809  */
 810 extern void krb5int_prng_cleanup(void);
 811
 812
 813 #ifdef KRB5_OLD_CRYPTO
 814 /* old provider api */
 815
 816 krb5_error_code krb5_crypto_os_localaddr(krb5_address ***);
 817
 818 krb5_error_code krb5_crypto_us_timeofday(krb5_int32 *, krb5_int32 *);
 819
 820 #endif /* KRB5_OLD_CRYPTO */
 821
 822 /* this helper fct is in libkrb5, but it makes sense declared here. */
 823
 824 krb5_error_code
 825 krb5_encrypt_keyhelper(krb5_context context, krb5_key key,
 826                        krb5_keyusage keyusage, const krb5_data *plain,
 827                        krb5_enc_data *cipher);
 828
 829 /*
 830  * End "los-proto.h"
 831  */
 832
 833 typedef struct _krb5_os_context {
 834     krb5_magic              magic;
 835     krb5_int32              time_offset;
 836     krb5_int32              usec_offset;
 837     krb5_int32              os_flags;
 838     char *                  default_ccname;
 839 } *krb5_os_context;
 840
 841 /*
 842  * Flags for the os_flags field
 843  *
 844  * KRB5_OS_TOFFSET_VALID means that the time offset fields are valid.
 845  * The intention is that this facility to correct the system clocks so
 846  * that they reflect the "real" time, for systems where for some
 847  * reason we can't set the system clock.  Instead we calculate the
 848  * offset between the system time and real time, and store the offset
 849  * in the os context so that we can correct the system clock as necessary.
 850  *
 851  * KRB5_OS_TOFFSET_TIME means that the time offset fields should be
 852  * returned as the time by the krb5 time routines.  This should only
 853  * be used for testing purposes (obviously!)
 854  */
 855 #define KRB5_OS_TOFFSET_VALID   1
 856 #define KRB5_OS_TOFFSET_TIME    2
 857
 858 /* lock mode flags */
 859 #define KRB5_LOCKMODE_SHARED    0x0001
 860 #define KRB5_LOCKMODE_EXCLUSIVE 0x0002
 861 #define KRB5_LOCKMODE_DONTBLOCK 0x0004
 862 #define KRB5_LOCKMODE_UNLOCK    0x0008
 863
 864 /*
 865  * Define our view of the size of a DES key.
 866  */
 867 #define KRB5_MIT_DES_KEYSIZE            8
 868 #define KRB5_MIT_DES3_KEYSIZE           24
 869 #define KRB5_MIT_DES3_KEY_BYTES         21
 870
 871 /*
 872  * Check if des_int.h has been included before us.  If so, then check to see
 873  * that our view of the DES key size is the same as des_int.h's.
 874  */
 875 #ifdef  MIT_DES_KEYSIZE
 876 #if     MIT_DES_KEYSIZE != KRB5_MIT_DES_KEYSIZE
 877 error(MIT_DES_KEYSIZE does not equal KRB5_MIT_DES_KEYSIZE)
 878 #endif  /* MIT_DES_KEYSIZE != KRB5_MIT_DES_KEYSIZE */
 879 #endif  /* MIT_DES_KEYSIZE */
 880
 881 /*
 882  * Begin "preauth.h"
 883  *
 884  * (Originally written by Glen Machin at Sandia Labs.)
 885  */
 886 /*
 887  * Sandia National Laboratories also makes no representations about the
 888  * suitability of the modifications, or additions to this software for
 889  * any purpose.  It is provided "as is" without express or implied warranty.
 890  *
 891  */
 892 #ifndef KRB5_PREAUTH__
 893 #define KRB5_PREAUTH__
 894
 895 #include <krb5/preauth_plugin.h>
 896
 897 #define CLIENT_ROCK_MAGIC 0x4352434b
 898 /* This structure is passed into the client preauth functions and passed
 899  * back to the "get_data_proc" function so that it can locate the
 900  * requested information.  It is opaque to the plugin code and can be
 901  * expanded in the future as new types of requests are defined which
 902  * may require other things to be passed through. */
 903 struct krb5int_fast_request_state;
 904 typedef struct _krb5_preauth_client_rock {
 905     krb5_magic      magic;
 906     krb5_enctype *etype;
 907     struct krb5int_fast_request_state *fast_state;
 908 } krb5_preauth_client_rock;
 909
 910 /* This structure lets us keep track of all of the modules which are loaded,
 911  * turning the list of modules and their lists of implemented preauth types
 912  * into a single list which we can walk easily. */
 913 typedef struct _krb5_preauth_context {
 914     int n_modules;
 915     struct _krb5_preauth_context_module {
 916         /* Which of the possibly more than one preauth types which the
 917          * module supports we're using at this point in the list. */
 918         krb5_preauthtype pa_type;
 919         /* Encryption types which the client claims to support -- we
 920          * copy them directly into the krb5_kdc_req structure during
 921          * krb5_preauth_prepare_request(). */
 922         krb5_enctype *enctypes;
 923         /* The plugin's per-plugin context and a function to clear it. */
 924         void *plugin_context;
 925         preauth_client_plugin_fini_proc client_fini;
 926         /* The module's table, and some of its members, copied here for
 927          * convenience when we populated the list. */
 928         struct krb5plugin_preauth_client_ftable_v1 *ftable;
 929         const char *name;
 930         int flags, use_count;
 931         preauth_client_process_proc client_process;
 932         preauth_client_tryagain_proc client_tryagain;
 933         preauth_client_supply_gic_opts_proc client_supply_gic_opts;
 934         preauth_client_request_init_proc client_req_init;
 935         preauth_client_request_fini_proc client_req_fini;
 936         /* The per-request context which the client_req_init() function
 937          * might allocate, which we'll need to clean up later by
 938          * calling the client_req_fini() function. */
 939         void *request_context;
 940         /* A pointer to the request_context pointer.  All modules within
 941          * a plugin will point at the request_context of the first
 942          * module within the plugin. */
 943         void **request_context_pp;
 944     } *modules;
 945 } krb5_preauth_context;
 946
 947 typedef struct _krb5_pa_enc_ts {
 948     krb5_timestamp      patimestamp;
 949     krb5_int32          pausec;
 950 } krb5_pa_enc_ts;
 951
 952 typedef struct _krb5_pa_for_user {
 953     krb5_principal      user;
 954     krb5_checksum       cksum;
 955     krb5_data           auth_package;
 956 } krb5_pa_for_user;
 957
 958 typedef struct _krb5_s4u_userid {
 959     krb5_int32          nonce;
 960     krb5_principal      user;
 961     krb5_data           subject_cert;
 962     krb5_flags          options;
 963 } krb5_s4u_userid;
 964
 965 #define KRB5_S4U_OPTS_CHECK_LOGON_HOURS         0x40000000 /* check logon hour restrictions */
 966 #define KRB5_S4U_OPTS_USE_REPLY_KEY_USAGE       0x20000000 /* sign with usage 27 instead of 26 */
 967
 968 typedef struct _krb5_pa_s4u_x509_user {
 969     krb5_s4u_userid     user_id;
 970     krb5_checksum       cksum;
 971 } krb5_pa_s4u_x509_user;
 972
 973 enum {
 974     KRB5_FAST_ARMOR_AP_REQUEST = 0x1
 975 };
 976
 977 typedef struct _krb5_fast_armor {
 978     krb5_int32 armor_type;
 979     krb5_data armor_value;
 980 } krb5_fast_armor;
 981 typedef struct _krb5_fast_armored_req {
 982     krb5_magic magic;
 983     krb5_fast_armor *armor;
 984     krb5_checksum req_checksum;
 985     krb5_enc_data enc_part;
 986 } krb5_fast_armored_req;
 987
 988 typedef struct _krb5_fast_req {
 989     krb5_magic magic;
 990     krb5_flags fast_options;
 991     /* padata from req_body is used*/
 992     krb5_kdc_req *req_body;
 993 } krb5_fast_req;
 994
 995 /* Bits 0-15 are critical in fast options.*/
 996 #define UNSUPPORTED_CRITICAL_FAST_OPTIONS 0x00ff
 997 #define KRB5_FAST_OPTION_HIDE_CLIENT_NAMES 0x01
 998
 999 typedef struct _krb5_fast_finished {
1000     krb5_timestamp timestamp;
1001     krb5_int32 usec;
1002     krb5_principal client;
1003     krb5_checksum ticket_checksum;
1004 } krb5_fast_finished;
1005
1006 typedef struct _krb5_fast_response {
1007     krb5_magic magic;
1008     krb5_pa_data **padata;
1009     krb5_keyblock *strengthen_key;
1010     krb5_fast_finished *finished;
1011     krb5_int32 nonce;
1012 } krb5_fast_response;
1013
1014 typedef struct _krb5_ad_kdcissued {
1015     krb5_checksum ad_checksum;
1016     krb5_principal i_principal;
1017     krb5_authdata **elements;
1018 } krb5_ad_kdcissued;
1019
1020 typedef struct _krb5_ad_signedpath_data {
1021     krb5_principal client;
1022     krb5_timestamp authtime;
1023     krb5_principal *delegated;
1024     krb5_pa_data **method_data;
1025     krb5_authdata **authorization_data;
1026 } krb5_ad_signedpath_data;
1027
1028 typedef struct _krb5_ad_signedpath {
1029     krb5_enctype enctype;
1030     krb5_checksum checksum;
1031     krb5_principal *delegated;
1032     krb5_pa_data **method_data;
1033 } krb5_ad_signedpath;
1034
1035 typedef krb5_error_code
1036 (*krb5_preauth_obtain_proc)(krb5_context, krb5_pa_data *,
1037                             krb5_etype_info, krb5_keyblock *,
1038                             krb5_error_code (*)(krb5_context,
1039                                                 const krb5_enctype,
1040                                                 krb5_data *,
1041                                                 krb5_const_pointer,
1042                                                 krb5_keyblock **),
1043                             krb5_const_pointer, krb5_creds *,
1044                             krb5_kdc_req *, krb5_pa_data **);
1045
1046 typedef krb5_error_code
1047 (*krb5_preauth_process_proc)(krb5_context, krb5_pa_data *, krb5_kdc_req *,
1048                              krb5_kdc_rep *,
1049                              krb5_error_code (*)(krb5_context,
1050                                                  const krb5_enctype,
1051                                                  krb5_data *,
1052                                                  krb5_const_pointer,
1053                                                  krb5_keyblock **),
1054                              krb5_const_pointer,
1055                              krb5_error_code (*)(krb5_context,
1056                                                  const krb5_keyblock *,
1057                                                  krb5_const_pointer,
1058                                                  krb5_kdc_rep * ),
1059                              krb5_keyblock **, krb5_creds *, krb5_int32 *,
1060                              krb5_int32 *);
1061
1062 typedef struct _krb5_preauth_ops {
1063     krb5_magic magic;
1064     int     type;
1065     int flags;
1066     krb5_preauth_obtain_proc    obtain;
1067     krb5_preauth_process_proc   process;
1068 } krb5_preauth_ops;
1069
1070 krb5_error_code
1071 krb5_obtain_padata(krb5_context, krb5_pa_data **,
1072                    krb5_error_code (*)(krb5_context, const krb5_enctype,
1073                                        krb5_data *, krb5_const_pointer,
1074                                        krb5_keyblock **),
1075                    krb5_const_pointer, krb5_creds *, krb5_kdc_req *);
1076
1077 krb5_error_code
1078 krb5_process_padata(krb5_context, krb5_kdc_req *, krb5_kdc_rep *,
1079                     krb5_error_code (*)(krb5_context, const krb5_enctype,
1080                                         krb5_data *, krb5_const_pointer,
1081                                         krb5_keyblock **),
1082                     krb5_const_pointer,
1083                     krb5_error_code (*)(krb5_context, const krb5_keyblock *,
1084                                         krb5_const_pointer, krb5_kdc_rep *),
1085                     krb5_keyblock **, krb5_creds *, krb5_int32 *);
1086
1087 krb5_pa_data *
1088 krb5int_find_pa_data(krb5_context, krb5_pa_data *const *, krb5_preauthtype);
1089 /* Does not return a copy; original padata sequence responsible for freeing*/
1090
1091 void krb5_free_etype_info(krb5_context, krb5_etype_info);
1092
1093 /*
1094  * Preauthentication property flags
1095  */
1096 #define KRB5_PREAUTH_FLAGS_ENCRYPT      0x00000001
1097 #define KRB5_PREAUTH_FLAGS_HARDWARE     0x00000002
1098
1099 #endif /* KRB5_PREAUTH__ */
1100 /*
1101  * End "preauth.h"
1102  */
1103
1104 /*
1105  * Extending the krb5_get_init_creds_opt structure.  The original
1106  * krb5_get_init_creds_opt structure is defined publicly.  The
1107  * new extended version is private.  The original interface
1108  * assumed a pre-allocated structure which was passed to
1109  * krb5_get_init_creds_init().  The new interface assumes that
1110  * the caller will call krb5_get_init_creds_alloc() and
1111  * krb5_get_init_creds_free().
1112  *
1113  * Callers MUST NOT call krb5_get_init_creds_init() after allocating an
1114  * opts structure using krb5_get_init_creds_alloc().  To do so will
1115  * introduce memory leaks.  Unfortunately, there is no way to enforce
1116  * this behavior.
1117  *
1118  * Two private flags are added for backward compatibility.
1119  * KRB5_GET_INIT_CREDS_OPT_EXTENDED says that the structure was allocated
1120  * with the new krb5_get_init_creds_opt_alloc() function.
1121  * KRB5_GET_INIT_CREDS_OPT_SHADOWED is set to indicate that the extended
1122  * structure is a shadow copy of an original krb5_get_init_creds_opt
1123  * structure.
1124  * If KRB5_GET_INIT_CREDS_OPT_SHADOWED is set after a call to
1125  * krb5int_gic_opt_to_opte(), the resulting extended structure should be
1126  * freed (using krb5_get_init_creds_free).  Otherwise, the original
1127  * structure was already extended and there is no need to free it.
1128  */
1129
1130 #define KRB5_GET_INIT_CREDS_OPT_EXTENDED 0x80000000
1131 #define KRB5_GET_INIT_CREDS_OPT_SHADOWED 0x40000000
1132
1133 #define krb5_gic_opt_is_extended(s)                                     \
1134     ((s) && ((s)->flags & KRB5_GET_INIT_CREDS_OPT_EXTENDED) ? 1 : 0)
1135 #define krb5_gic_opt_is_shadowed(s)                                     \
1136     ((s) && ((s)->flags & KRB5_GET_INIT_CREDS_OPT_SHADOWED) ? 1 : 0)
1137
1138
1139 typedef struct _krb5_gic_opt_private {
1140     int num_preauth_data;
1141     krb5_gic_opt_pa_data *preauth_data;
1142     char * fast_ccache_name;
1143     krb5_ccache out_ccache;
1144     krb5_flags fast_flags;
1145 } krb5_gic_opt_private;
1146
1147 /*
1148  * On the Mac, ensure that the layout of krb5_gic_opt_ext matches that
1149  * of krb5_get_init_creds_opt.
1150  */
1151 #if TARGET_OS_MAC
1152 #    pragma pack(push,2)
1153 #endif
1154
1155 typedef struct _krb5_gic_opt_ext {
1156     krb5_flags flags;
1157     krb5_deltat tkt_life;
1158     krb5_deltat renew_life;
1159     int forwardable;
1160     int proxiable;
1161     krb5_enctype *etype_list;
1162     int etype_list_length;
1163     krb5_address **address_list;
1164     krb5_preauthtype *preauth_list;
1165     int preauth_list_length;
1166     krb5_data *salt;
1167     /*
1168      * Do not change anything above this point in this structure.
1169      * It is identical to the public krb5_get_init_creds_opt structure.
1170      * New members must be added below.
1171      */
1172     krb5_gic_opt_private *opt_private;
1173 } krb5_gic_opt_ext;
1174
1175 #if TARGET_OS_MAC
1176 #    pragma pack(pop)
1177 #endif
1178
1179 krb5_error_code
1180 krb5int_gic_opt_to_opte(krb5_context context, krb5_get_init_creds_opt *opt,
1181                         krb5_gic_opt_ext **opte, unsigned int force,
1182                         const char *where);
1183
1184 krb5_error_code
1185 krb5int_copy_data_contents(krb5_context, const krb5_data *, krb5_data *);
1186
1187 krb5_error_code
1188 krb5int_copy_data_contents_add0(krb5_context, const krb5_data *, krb5_data *);
1189
1190 krb5_error_code
1191 krb5int_copy_creds_contents(krb5_context, const krb5_creds *, krb5_creds *);
1192
1193 typedef krb5_error_code
1194 (*krb5_gic_get_as_key_fct)(krb5_context, krb5_principal, krb5_enctype,
1195                            krb5_prompter_fct, void *prompter_data,
1196                            krb5_data *salt, krb5_data *s2kparams,
1197                            krb5_keyblock *as_key, void *gak_data);
1198
1199 krb5_error_code KRB5_CALLCONV
1200 krb5int_get_init_creds(krb5_context context, krb5_creds *creds,
1201                        krb5_principal client, krb5_prompter_fct prompter,
1202                        void *prompter_data, krb5_deltat start_time,
1203                        char *in_tkt_service, krb5_get_init_creds_opt *options,
1204                        krb5_gic_get_as_key_fct gak, void *gak_data,
1205                        int *master, krb5_kdc_rep **as_reply);
1206
1207 krb5_error_code
1208 krb5int_populate_gic_opt (krb5_context, krb5_get_init_creds_opt **,
1209                           krb5_flags options, krb5_address *const *addrs,
1210                           krb5_enctype *ktypes,
1211                           krb5_preauthtype *pre_auth_types, krb5_creds *creds);
1212
1213
1214 krb5_error_code KRB5_CALLCONV
1215 krb5_do_preauth(krb5_context context, krb5_kdc_req *request,
1216                 krb5_data *encoded_request_body,
1217                 krb5_data *encoded_previous_request, krb5_pa_data **in_padata,
1218                 krb5_pa_data ***out_padata, krb5_data *salt,
1219                 krb5_data *s2kparams, krb5_enctype *etype,
1220                 krb5_keyblock *as_key, krb5_prompter_fct prompter,
1221                 void *prompter_data, krb5_gic_get_as_key_fct gak_fct,
1222                 void *gak_data, krb5_preauth_client_rock *get_data_rock,
1223                 krb5_gic_opt_ext *opte);
1224
1225 krb5_error_code KRB5_CALLCONV
1226 krb5_do_preauth_tryagain(krb5_context context, krb5_kdc_req *request,
1227                          krb5_data *encoded_request_body,
1228                          krb5_data *encoded_previous_request,
1229                          krb5_pa_data **in_padata, krb5_pa_data ***out_padata,
1230                          krb5_error *err_reply,
1231                          krb5_data *salt, krb5_data *s2kparams,
1232                          krb5_enctype *etype, krb5_keyblock *as_key,
1233                          krb5_prompter_fct prompter, void *prompter_data,
1234                          krb5_gic_get_as_key_fct gak_fct, void *gak_data,
1235                          krb5_preauth_client_rock *get_data_rock,
1236                          krb5_gic_opt_ext *opte);
1237
1238 void KRB5_CALLCONV krb5_init_preauth_context(krb5_context);
1239 void KRB5_CALLCONV krb5_free_preauth_context(krb5_context);
1240 void KRB5_CALLCONV krb5_clear_preauth_context_use_counts(krb5_context);
1241 void KRB5_CALLCONV krb5_preauth_prepare_request(krb5_context,
1242                                                 krb5_gic_opt_ext *,
1243                                                 krb5_kdc_req *);
1244 void KRB5_CALLCONV krb5_preauth_request_context_init(krb5_context);
1245 void KRB5_CALLCONV krb5_preauth_request_context_fini(krb5_context);
1246
1247 void KRB5_CALLCONV
1248 krb5_free_sam_challenge(krb5_context, krb5_sam_challenge *);
1249
1250 void KRB5_CALLCONV
1251 krb5_free_sam_challenge_2(krb5_context, krb5_sam_challenge_2 *);
1252
1253 void KRB5_CALLCONV
1254 krb5_free_sam_challenge_2_body(krb5_context, krb5_sam_challenge_2_body *);
1255
1256 void KRB5_CALLCONV
1257 krb5_free_sam_response(krb5_context, krb5_sam_response *);
1258
1259 void KRB5_CALLCONV
1260 krb5_free_sam_response_2(krb5_context, krb5_sam_response_2 *);
1261
1262 void KRB5_CALLCONV
1263 krb5_free_predicted_sam_response(krb5_context, krb5_predicted_sam_response *);
1264
1265 void KRB5_CALLCONV
1266 krb5_free_enc_sam_response_enc(krb5_context, krb5_enc_sam_response_enc *);
1267
1268 void KRB5_CALLCONV
1269 krb5_free_enc_sam_response_enc_2(krb5_context, krb5_enc_sam_response_enc_2 *);
1270
1271 void KRB5_CALLCONV
1272 krb5_free_sam_challenge_contents(krb5_context, krb5_sam_challenge *);
1273
1274 void KRB5_CALLCONV
1275 krb5_free_sam_challenge_2_contents(krb5_context, krb5_sam_challenge_2 *);
1276
1277 void KRB5_CALLCONV
1278 krb5_free_sam_challenge_2_body_contents(krb5_context,
1279                                         krb5_sam_challenge_2_body *);
1280
1281 void KRB5_CALLCONV
1282 krb5_free_sam_response_contents(krb5_context, krb5_sam_response *);
1283
1284 void KRB5_CALLCONV
1285 krb5_free_sam_response_2_contents(krb5_context, krb5_sam_response_2 *);
1286
1287 void KRB5_CALLCONV
1288 krb5_free_predicted_sam_response_contents(krb5_context,
1289                                           krb5_predicted_sam_response * );
1290
1291 void KRB5_CALLCONV
1292 krb5_free_enc_sam_response_enc_contents(krb5_context,
1293                                         krb5_enc_sam_response_enc * );
1294
1295 void KRB5_CALLCONV
1296 krb5_free_enc_sam_response_enc_2_contents(krb5_context,
1297                                           krb5_enc_sam_response_enc_2 * );
1298
1299 void KRB5_CALLCONV
1300 krb5_free_pa_enc_ts(krb5_context, krb5_pa_enc_ts *);
1301
1302 void KRB5_CALLCONV
1303 krb5_free_pa_for_user(krb5_context, krb5_pa_for_user *);
1304
1305 void KRB5_CALLCONV
1306 krb5_free_s4u_userid_contents(krb5_context, krb5_s4u_userid *);
1307
1308 void KRB5_CALLCONV
1309 krb5_free_pa_s4u_x509_user(krb5_context, krb5_pa_s4u_x509_user *);
1310
1311 void KRB5_CALLCONV
1312 krb5_free_pa_svr_referral_data(krb5_context, krb5_pa_svr_referral_data *);
1313
1314 void KRB5_CALLCONV
1315 krb5_free_pa_server_referral_data(krb5_context,
1316                                   krb5_pa_server_referral_data * );
1317
1318 void KRB5_CALLCONV
1319 krb5_free_pa_pac_req(krb5_context, krb5_pa_pac_req * );
1320
1321 void KRB5_CALLCONV
1322 krb5_free_etype_list(krb5_context, krb5_etype_list * );
1323
1324 void KRB5_CALLCONV krb5_free_fast_armor(krb5_context, krb5_fast_armor *);
1325 void KRB5_CALLCONV krb5_free_fast_armored_req(krb5_context,
1326                                               krb5_fast_armored_req *);
1327 void KRB5_CALLCONV krb5_free_fast_req(krb5_context, krb5_fast_req *);
1328 void KRB5_CALLCONV krb5_free_fast_finished(krb5_context, krb5_fast_finished *);
1329 void KRB5_CALLCONV krb5_free_fast_response(krb5_context, krb5_fast_response *);
1330 void KRB5_CALLCONV krb5_free_ad_kdcissued(krb5_context, krb5_ad_kdcissued *);
1331 void KRB5_CALLCONV krb5_free_ad_signedpath(krb5_context, krb5_ad_signedpath *);
1332
1333 /* #include "krb5/wordsize.h" -- comes in through base-defs.h. */
1334 #include "com_err.h"
1335 #include "k5-plugin.h"
1336
1337 #include <krb5/authdata_plugin.h>
1338
1339 struct _krb5_authdata_context {
1340     krb5_magic magic;
1341     int n_modules;
1342     struct _krb5_authdata_context_module {
1343         krb5_authdatatype ad_type;
1344         void *plugin_context;
1345         authdata_client_plugin_fini_proc client_fini;
1346         krb5_flags flags;
1347         krb5plugin_authdata_client_ftable_v0 *ftable;
1348         authdata_client_request_init_proc client_req_init;
1349         authdata_client_request_fini_proc client_req_fini;
1350         const char *name;
1351         void *request_context;
1352         void **request_context_pp;
1353     } *modules;
1354     struct plugin_dir_handle plugins;
1355 };
1356
1357 typedef struct _krb5_authdata_context *krb5_authdata_context;
1358
1359 void KRB5_CALLCONV
1360 krb5int_free_data_list(krb5_context context, krb5_data *data);
1361
1362 krb5_error_code KRB5_CALLCONV
1363 krb5_authdata_context_init(krb5_context kcontext,
1364                            krb5_authdata_context *pcontext);
1365
1366 void KRB5_CALLCONV
1367 krb5_authdata_context_free(krb5_context kcontext,
1368                            krb5_authdata_context context);
1369
1370 krb5_error_code KRB5_CALLCONV
1371 krb5_authdata_export_authdata(krb5_context kcontext,
1372                               krb5_authdata_context context, krb5_flags usage,
1373                               krb5_authdata ***pauthdata);
1374
1375 krb5_error_code KRB5_CALLCONV
1376 krb5_authdata_get_attribute_types(krb5_context kcontext,
1377                                   krb5_authdata_context context,
1378                                   krb5_data **attrs);
1379
1380 krb5_error_code KRB5_CALLCONV
1381 krb5_authdata_get_attribute(krb5_context kcontext,
1382                             krb5_authdata_context context,
1383                             const krb5_data *attribute,
1384                             krb5_boolean *authenticated,
1385                             krb5_boolean *complete, krb5_data *value,
1386                             krb5_data *display_value, int *more);
1387
1388 krb5_error_code KRB5_CALLCONV
1389 krb5_authdata_set_attribute(krb5_context kcontext,
1390                             krb5_authdata_context context,
1391                             krb5_boolean complete, const krb5_data *attribute,
1392                             const krb5_data *value);
1393
1394 krb5_error_code KRB5_CALLCONV
1395 krb5_authdata_delete_attribute(krb5_context kcontext,
1396                                krb5_authdata_context context,
1397                                const krb5_data *attribute);
1398
1399 krb5_error_code KRB5_CALLCONV
1400 krb5_authdata_import_attributes(krb5_context kcontext,
1401                                 krb5_authdata_context context,
1402                                 krb5_flags usage, const krb5_data *attributes);
1403
1404 krb5_error_code KRB5_CALLCONV
1405 krb5_authdata_export_attributes(krb5_context kcontext,
1406                                 krb5_authdata_context context,
1407                                 krb5_flags usage, krb5_data **pattributes);
1408
1409 krb5_error_code KRB5_CALLCONV
1410 krb5_authdata_export_internal(krb5_context kcontext,
1411                               krb5_authdata_context context,
1412                               krb5_boolean restrict_authenticated,
1413                               const char *module, void **ptr);
1414
1415 krb5_error_code KRB5_CALLCONV
1416 krb5_authdata_context_copy(krb5_context kcontext, krb5_authdata_context src,
1417                            krb5_authdata_context *dst);
1418
1419 krb5_error_code KRB5_CALLCONV
1420 krb5_authdata_free_internal(krb5_context kcontext,
1421                             krb5_authdata_context context, const char *module,
1422                             void *ptr);
1423
1424 struct _kdb5_dal_handle;        /* private, in kdb5.h */
1425 typedef struct _kdb5_dal_handle kdb5_dal_handle;
1426 struct _kdb_log_context;
1427 struct _krb5_context {
1428     krb5_magic      magic;
1429     krb5_enctype    *in_tkt_etypes;
1430     krb5_enctype    *tgs_etypes;
1431     struct _krb5_os_context os_context;
1432     char            *default_realm;
1433     profile_t       profile;
1434     kdb5_dal_handle *dal_handle;
1435     int             ser_ctx_count;
1436     void            *ser_ctx;
1437     /* allowable clock skew */
1438     krb5_deltat     clockskew;
1439     krb5_cksumtype  kdc_req_sumtype;
1440     krb5_cksumtype  default_ap_req_sumtype;
1441     krb5_cksumtype  default_safe_sumtype;
1442     krb5_flags      kdc_default_options;
1443     krb5_flags      library_options;
1444     krb5_boolean    profile_secure;
1445     int             fcc_default_format;
1446     krb5_prompt_type *prompt_types;
1447     /* Message size above which we'll try TCP first in send-to-kdc
1448        type code.  Aside from the 2**16 size limit, we put no
1449        absolute limit on the UDP packet size.  */
1450     int             udp_pref_limit;
1451
1452     /* Use the config-file ktypes instead of app-specified?  */
1453     krb5_boolean    use_conf_ktypes;
1454
1455 #ifdef KRB5_DNS_LOOKUP
1456     krb5_boolean    profile_in_memory;
1457 #endif /* KRB5_DNS_LOOKUP */
1458
1459     /* locate_kdc module stuff */
1460     struct plugin_dir_handle libkrb5_plugins;
1461     struct krb5plugin_service_locate_ftable *vtbl;
1462     void (**locate_fptrs)(void);
1463
1464     /* preauth module stuff */
1465     struct plugin_dir_handle preauth_plugins;
1466     krb5_preauth_context *preauth_context;
1467
1468     /* error detail info */
1469     struct errinfo err;
1470
1471     /* For Sun iprop code; does this really have to be here?  */
1472     struct _kdb_log_context *kdblog_context;
1473
1474     krb5_boolean allow_weak_crypto;
1475 };
1476
1477 /* could be used in a table to find an etype and initialize a block */
1478
1479
1480 #define KRB5_LIBOPT_SYNC_KDCTIME        0x0001
1481
1482 /* internal message representations */
1483
1484 typedef struct _krb5_safe {
1485     krb5_magic magic;
1486     krb5_data user_data;                /* user data */
1487     krb5_timestamp timestamp;           /* client time, optional */
1488     krb5_int32 usec;                    /* microsecond portion of time,
1489                                            optional */
1490     krb5_ui_4 seq_number;               /* sequence #, optional */
1491     krb5_address *s_address;    /* sender address */
1492     krb5_address *r_address;    /* recipient address, optional */
1493     krb5_checksum *checksum;    /* data integrity checksum */
1494 } krb5_safe;
1495
1496 typedef struct _krb5_priv {
1497     krb5_magic magic;
1498     krb5_enc_data enc_part;             /* encrypted part */
1499 } krb5_priv;
1500
1501 typedef struct _krb5_priv_enc_part {
1502     krb5_magic magic;
1503     krb5_data user_data;                /* user data */
1504     krb5_timestamp timestamp;           /* client time, optional */
1505     krb5_int32 usec;                    /* microsecond portion of time, opt. */
1506     krb5_ui_4 seq_number;               /* sequence #, optional */
1507     krb5_address *s_address;    /* sender address */
1508     krb5_address *r_address;    /* recipient address, optional */
1509 } krb5_priv_enc_part;
1510
1511 void KRB5_CALLCONV krb5_free_safe(krb5_context, krb5_safe *);
1512 void KRB5_CALLCONV krb5_free_priv(krb5_context, krb5_priv *);
1513 void KRB5_CALLCONV krb5_free_priv_enc_part(krb5_context, krb5_priv_enc_part *);
1514
1515 /*
1516  * Begin "asn1.h"
1517  */
1518 #ifndef KRB5_ASN1__
1519 #define KRB5_ASN1__
1520
1521 /* ASN.1 encoding knowledge; KEEP IN SYNC WITH ASN.1 defs! */
1522 /* here we use some knowledge of ASN.1 encodings */
1523 /*
1524   Ticket is APPLICATION 1.
1525   Authenticator is APPLICATION 2.
1526   AS_REQ is APPLICATION 10.
1527   AS_REP is APPLICATION 11.
1528   TGS_REQ is APPLICATION 12.
1529   TGS_REP is APPLICATION 13.
1530   AP_REQ is APPLICATION 14.
1531   AP_REP is APPLICATION 15.
1532   KRB_SAFE is APPLICATION 20.
1533   KRB_PRIV is APPLICATION 21.
1534   KRB_CRED is APPLICATION 22.
1535   EncASRepPart is APPLICATION 25.
1536   EncTGSRepPart is APPLICATION 26.
1537   EncAPRepPart is APPLICATION 27.
1538   EncKrbPrivPart is APPLICATION 28.
1539   EncKrbCredPart is APPLICATION 29.
1540   KRB_ERROR is APPLICATION 30.
1541 */
1542 /* allow either constructed or primitive encoding, so check for bit 6
1543    set or reset */
1544 #define krb5int_is_app_tag(dat,tag)                     \
1545     ((dat != NULL) && (dat)->length &&                  \
1546      ((((dat)->data[0] & ~0x20) == ((tag) | 0x40))))
1547 #define krb5_is_krb_ticket(dat)               krb5int_is_app_tag(dat, 1)
1548 #define krb5_is_krb_authenticator(dat)        krb5int_is_app_tag(dat, 2)
1549 #define krb5_is_as_req(dat)                   krb5int_is_app_tag(dat, 10)
1550 #define krb5_is_as_rep(dat)                   krb5int_is_app_tag(dat, 11)
1551 #define krb5_is_tgs_req(dat)                  krb5int_is_app_tag(dat, 12)
1552 #define krb5_is_tgs_rep(dat)                  krb5int_is_app_tag(dat, 13)
1553 #define krb5_is_ap_req(dat)                   krb5int_is_app_tag(dat, 14)
1554 #define krb5_is_ap_rep(dat)                   krb5int_is_app_tag(dat, 15)
1555 #define krb5_is_krb_safe(dat)                 krb5int_is_app_tag(dat, 20)
1556 #define krb5_is_krb_priv(dat)                 krb5int_is_app_tag(dat, 21)
1557 #define krb5_is_krb_cred(dat)                 krb5int_is_app_tag(dat, 22)
1558 #define krb5_is_krb_enc_as_rep_part(dat)      krb5int_is_app_tag(dat, 25)
1559 #define krb5_is_krb_enc_tgs_rep_part(dat)     krb5int_is_app_tag(dat, 26)
1560 #define krb5_is_krb_enc_ap_rep_part(dat)      krb5int_is_app_tag(dat, 27)
1561 #define krb5_is_krb_enc_krb_priv_part(dat)    krb5int_is_app_tag(dat, 28)
1562 #define krb5_is_krb_enc_krb_cred_part(dat)    krb5int_is_app_tag(dat, 29)
1563 #define krb5_is_krb_error(dat)                krb5int_is_app_tag(dat, 30)
1564
1565 /*************************************************************************
1566  * Prototypes for krb5_encode.c
1567  *************************************************************************/
1568
1569 /*
1570   krb5_error_code encode_krb5_structure(const krb5_structure *rep,
1571   krb5_data **code);
1572   modifies  *code
1573   effects   Returns the ASN.1 encoding of *rep in **code.
1574   Returns ASN1_MISSING_FIELD if a required field is emtpy in *rep.
1575   Returns ENOMEM if memory runs out.
1576 */
1577
1578 krb5_error_code
1579 encode_krb5_authenticator(const krb5_authenticator *rep, krb5_data **code);
1580
1581 krb5_error_code
1582 encode_krb5_ticket(const krb5_ticket *rep, krb5_data **code);
1583
1584 krb5_error_code
1585 encode_krb5_enc_tkt_part(const krb5_enc_tkt_part *rep, krb5_data **code);
1586
1587 krb5_error_code
1588 encode_krb5_enc_kdc_rep_part(const krb5_enc_kdc_rep_part *rep,
1589                              krb5_data **code);
1590
1591 /* yes, the translation is identical to that used for KDC__REP */
1592 krb5_error_code
1593 encode_krb5_as_rep(const krb5_kdc_rep *rep, krb5_data **code);
1594
1595 /* yes, the translation is identical to that used for KDC__REP */
1596 krb5_error_code
1597 encode_krb5_tgs_rep(const krb5_kdc_rep *rep, krb5_data **code);
1598
1599 krb5_error_code
1600 encode_krb5_ap_req(const krb5_ap_req *rep, krb5_data **code);
1601
1602 krb5_error_code
1603 encode_krb5_ap_rep(const krb5_ap_rep *rep, krb5_data **code);
1604
1605 krb5_error_code
1606 encode_krb5_ap_rep_enc_part(const krb5_ap_rep_enc_part *rep, krb5_data **code);
1607
1608 krb5_error_code
1609 encode_krb5_as_req(const krb5_kdc_req *rep, krb5_data **code);
1610
1611 krb5_error_code
1612 encode_krb5_tgs_req(const krb5_kdc_req *rep, krb5_data **code);
1613
1614 krb5_error_code
1615 encode_krb5_kdc_req_body(const krb5_kdc_req *rep, krb5_data **code);
1616
1617 krb5_error_code
1618 encode_krb5_safe(const krb5_safe *rep, krb5_data **code);
1619
1620 struct krb5_safe_with_body {
1621     krb5_safe *safe;
1622     krb5_data *body;
1623 };
1624 krb5_error_code
1625 encode_krb5_safe_with_body(const struct krb5_safe_with_body *rep,
1626                            krb5_data **code);
1627
1628 krb5_error_code
1629 encode_krb5_priv(const krb5_priv *rep, krb5_data **code);
1630
1631 krb5_error_code
1632 encode_krb5_enc_priv_part(const krb5_priv_enc_part *rep, krb5_data **code);
1633
1634 krb5_error_code
1635 encode_krb5_cred(const krb5_cred *rep, krb5_data **code);
1636 krb5_error_code
1637 encode_krb5_checksum(const krb5_checksum *, krb5_data **);
1638
1639 krb5_error_code
1640 encode_krb5_enc_cred_part(const krb5_cred_enc_part *rep, krb5_data **code);
1641
1642 krb5_error_code
1643 encode_krb5_error(const krb5_error *rep, krb5_data **code);
1644
1645 krb5_error_code
1646 encode_krb5_authdata(krb5_authdata *const *rep, krb5_data **code);
1647
1648 krb5_error_code
1649 encode_krb5_authdata_elt(const krb5_authdata *rep, krb5_data **code);
1650
1651 krb5_error_code
1652 encode_krb5_pwd_sequence(const passwd_phrase_element *rep, krb5_data **code);
1653
1654 krb5_error_code
1655 encode_krb5_pwd_data(const krb5_pwd_data *rep, krb5_data **code);
1656
1657 krb5_error_code
1658 encode_krb5_padata_sequence(krb5_pa_data *const *rep, krb5_data **code);
1659
1660 krb5_error_code
1661 encode_krb5_alt_method(const krb5_alt_method *, krb5_data **code);
1662
1663 krb5_error_code
1664 encode_krb5_etype_info(krb5_etype_info_entry *const *, krb5_data **code);
1665
1666 krb5_error_code
1667 encode_krb5_etype_info2(krb5_etype_info_entry *const *, krb5_data **code);
1668
1669 krb5_error_code
1670 encode_krb5_pa_enc_ts(const krb5_pa_enc_ts *, krb5_data **);
1671
1672 krb5_error_code
1673 encode_krb5_sam_challenge(const krb5_sam_challenge * , krb5_data **);
1674
1675 krb5_error_code
1676 encode_krb5_sam_key(const krb5_sam_key * , krb5_data **);
1677
1678 krb5_error_code
1679 encode_krb5_enc_sam_response_enc(const krb5_enc_sam_response_enc *,
1680                                  krb5_data **);
1681
1682 krb5_error_code
1683 encode_krb5_sam_response(const krb5_sam_response *, krb5_data **);
1684
1685 #if 0 /* currently not compiled because we never use them */
1686 krb5_error_code
1687 encode_krb5_sam_challenge_2(const krb5_sam_challenge_2 * , krb5_data **);
1688
1689 krb5_error_code
1690 encode_krb5_sam_challenge_2_body(const krb5_sam_challenge_2_body *,
1691                                  krb5_data **);
1692 #endif
1693
1694 krb5_error_code
1695 encode_krb5_enc_sam_response_enc_2(const krb5_enc_sam_response_enc_2 *,
1696                                    krb5_data **);
1697
1698 krb5_error_code
1699 encode_krb5_sam_response_2(const krb5_sam_response_2 * , krb5_data **);
1700
1701 krb5_error_code
1702 encode_krb5_predicted_sam_response(const krb5_predicted_sam_response *,
1703                                    krb5_data **);
1704
1705 struct krb5_setpw_req {
1706     krb5_principal target;
1707     krb5_data password;
1708 };
1709 krb5_error_code
1710 encode_krb5_setpw_req(const struct krb5_setpw_req *rep, krb5_data **code);
1711
1712 krb5_error_code
1713 encode_krb5_pa_for_user(const krb5_pa_for_user *, krb5_data **);
1714
1715 krb5_error_code
1716 encode_krb5_s4u_userid(const krb5_s4u_userid *, krb5_data **);
1717
1718 krb5_error_code
1719 encode_krb5_pa_s4u_x509_user(const krb5_pa_s4u_x509_user *, krb5_data **);
1720
1721 krb5_error_code
1722 encode_krb5_pa_svr_referral_data(const krb5_pa_svr_referral_data *,
1723                                  krb5_data **);
1724
1725 krb5_error_code
1726 encode_krb5_pa_server_referral_data(const krb5_pa_server_referral_data *,
1727                                     krb5_data **);
1728
1729 krb5_error_code
1730 encode_krb5_pa_pac_req(const krb5_pa_pac_req *, krb5_data **);
1731
1732 krb5_error_code
1733 encode_krb5_etype_list(const krb5_etype_list * , krb5_data **);
1734
1735 krb5_error_code
1736 encode_krb5_pa_fx_fast_request(const krb5_fast_armored_req *, krb5_data **);
1737
1738 krb5_error_code
1739 encode_krb5_fast_req(const krb5_fast_req *, krb5_data **);
1740
1741 krb5_error_code
1742 encode_krb5_pa_fx_fast_reply(const krb5_enc_data *, krb5_data **);
1743
1744 krb5_error_code
1745 encode_krb5_fast_response(const krb5_fast_response *, krb5_data **);
1746
1747 krb5_error_code
1748 encode_krb5_ad_kdcissued(const krb5_ad_kdcissued *, krb5_data **);
1749
1750 krb5_error_code
1751 encode_krb5_ad_signedpath(const krb5_ad_signedpath *, krb5_data **);
1752
1753 krb5_error_code
1754 encode_krb5_ad_signedpath_data(const krb5_ad_signedpath_data *, krb5_data **);
1755
1756 /*************************************************************************
1757  * End of prototypes for krb5_encode.c
1758  *************************************************************************/
1759
1760 krb5_error_code
1761 decode_krb5_sam_challenge(const krb5_data *, krb5_sam_challenge **);
1762
1763 krb5_error_code
1764 decode_krb5_enc_sam_key(const krb5_data *, krb5_sam_key **);
1765
1766 krb5_error_code
1767 decode_krb5_enc_sam_response_enc(const krb5_data *,
1768                                  krb5_enc_sam_response_enc **);
1769
1770 krb5_error_code
1771 decode_krb5_sam_response(const krb5_data *, krb5_sam_response **);
1772
1773 krb5_error_code
1774 decode_krb5_predicted_sam_response(const krb5_data *,
1775                                    krb5_predicted_sam_response **);
1776
1777 krb5_error_code
1778 decode_krb5_sam_challenge_2(const krb5_data *, krb5_sam_challenge_2 **);
1779
1780 krb5_error_code
1781 decode_krb5_sam_challenge_2_body(const krb5_data *,
1782                                  krb5_sam_challenge_2_body **);
1783
1784 krb5_error_code
1785 decode_krb5_enc_sam_response_enc_2(const krb5_data *,
1786                                    krb5_enc_sam_response_enc_2 **);
1787
1788 krb5_error_code
1789 decode_krb5_sam_response_2(const krb5_data *, krb5_sam_response_2 **);
1790
1791
1792 /*************************************************************************
1793  * Prototypes for krb5_decode.c
1794  *************************************************************************/
1795 /*
1796   krb5_error_code decode_krb5_structure(const krb5_data *code,
1797   krb5_structure **rep);
1798
1799   requires  Expects **rep to not have been allocated;
1800   a new *rep is allocated regardless of the old value.
1801   effects   Decodes *code into **rep.
1802   Returns ENOMEM if memory is exhausted.
1803   Returns asn1 and krb5 errors.
1804 */
1805
1806 krb5_error_code
1807 decode_krb5_authenticator(const krb5_data *code, krb5_authenticator **rep);
1808
1809 krb5_error_code
1810 decode_krb5_ticket(const krb5_data *code, krb5_ticket **rep);
1811
1812 krb5_error_code
1813 decode_krb5_encryption_key(const krb5_data *output, krb5_keyblock **rep);
1814
1815 krb5_error_code
1816 decode_krb5_enc_tkt_part(const krb5_data *output, krb5_enc_tkt_part **rep);
1817
1818 krb5_error_code
1819 decode_krb5_enc_kdc_rep_part(const krb5_data *output,
1820                              krb5_enc_kdc_rep_part **rep);
1821
1822 krb5_error_code
1823 decode_krb5_as_rep(const krb5_data *output, krb5_kdc_rep **rep);
1824
1825 krb5_error_code
1826 decode_krb5_tgs_rep(const krb5_data *output, krb5_kdc_rep **rep);
1827
1828 krb5_error_code
1829 decode_krb5_ap_req(const krb5_data *output, krb5_ap_req **rep);
1830
1831 krb5_error_code
1832 decode_krb5_ap_rep(const krb5_data *output, krb5_ap_rep **rep);
1833
1834 krb5_error_code
1835 decode_krb5_ap_rep_enc_part(const krb5_data *output,
1836                             krb5_ap_rep_enc_part **rep);
1837
1838 krb5_error_code
1839 decode_krb5_as_req(const krb5_data *output, krb5_kdc_req **rep);
1840
1841 krb5_error_code
1842 decode_krb5_tgs_req(const krb5_data *output, krb5_kdc_req **rep);
1843
1844 krb5_error_code
1845 decode_krb5_kdc_req_body(const krb5_data *output, krb5_kdc_req **rep);
1846
1847 krb5_error_code
1848 decode_krb5_safe(const krb5_data *output, krb5_safe **rep);
1849
1850 krb5_error_code
1851 decode_krb5_safe_with_body(const krb5_data *output, krb5_safe **rep,
1852                            krb5_data *body);
1853
1854 krb5_error_code
1855 decode_krb5_priv(const krb5_data *output, krb5_priv **rep);
1856
1857 krb5_error_code
1858 decode_krb5_enc_priv_part(const krb5_data *output, krb5_priv_enc_part **rep);
1859 krb5_error_code
1860 decode_krb5_checksum(const krb5_data *, krb5_checksum **);
1861
1862 krb5_error_code
1863 decode_krb5_cred(const krb5_data *output, krb5_cred **rep);
1864
1865 krb5_error_code
1866 decode_krb5_enc_cred_part(const krb5_data *output, krb5_cred_enc_part **rep);
1867
1868 krb5_error_code
1869 decode_krb5_error(const krb5_data *output, krb5_error **rep);
1870
1871 krb5_error_code
1872 decode_krb5_authdata(const krb5_data *output, krb5_authdata ***rep);
1873
1874 krb5_error_code
1875 decode_krb5_pwd_sequence(const krb5_data *output, passwd_phrase_element **rep);
1876
1877 krb5_error_code
1878 decode_krb5_pwd_data(const krb5_data *output, krb5_pwd_data **rep);
1879
1880 krb5_error_code
1881 decode_krb5_padata_sequence(const krb5_data *output, krb5_pa_data ***rep);
1882
1883 krb5_error_code
1884 decode_krb5_alt_method(const krb5_data *output, krb5_alt_method **rep);
1885
1886 krb5_error_code
1887 decode_krb5_etype_info(const krb5_data *output, krb5_etype_info_entry ***rep);
1888
1889 krb5_error_code
1890 decode_krb5_etype_info2(const krb5_data *output, krb5_etype_info_entry ***rep);
1891
1892 krb5_error_code
1893 decode_krb5_enc_data(const krb5_data *output, krb5_enc_data **rep);
1894
1895 krb5_error_code
1896 decode_krb5_pa_enc_ts(const krb5_data *output, krb5_pa_enc_ts **rep);
1897
1898 krb5_error_code
1899 decode_krb5_sam_key(const krb5_data *, krb5_sam_key **);
1900
1901 krb5_error_code
1902 decode_krb5_setpw_req(const krb5_data *, krb5_data **, krb5_principal *);
1903
1904 krb5_error_code
1905 decode_krb5_pa_for_user(const krb5_data *, krb5_pa_for_user **);
1906
1907 krb5_error_code
1908 decode_krb5_pa_s4u_x509_user(const krb5_data *, krb5_pa_s4u_x509_user **);
1909
1910 krb5_error_code
1911 decode_krb5_pa_svr_referral_data(const krb5_data *,
1912                                  krb5_pa_svr_referral_data **);
1913
1914 krb5_error_code
1915 decode_krb5_pa_server_referral_data(const krb5_data *,
1916                                     krb5_pa_server_referral_data **);
1917
1918 krb5_error_code
1919 decode_krb5_pa_pac_req(const krb5_data *, krb5_pa_pac_req **);
1920
1921 krb5_error_code
1922 decode_krb5_etype_list(const krb5_data *, krb5_etype_list **);
1923
1924 krb5_error_code
1925 decode_krb5_pa_fx_fast_request(const krb5_data *, krb5_fast_armored_req **);
1926
1927 krb5_error_code
1928 decode_krb5_fast_req(const krb5_data *, krb5_fast_req **);
1929
1930 krb5_error_code
1931 decode_krb5_pa_fx_fast_reply(const krb5_data *, krb5_enc_data **);
1932
1933 krb5_error_code
1934 decode_krb5_fast_response(const krb5_data *, krb5_fast_response **);
1935
1936 krb5_error_code
1937 decode_krb5_ad_kdcissued(const krb5_data *, krb5_ad_kdcissued **);
1938
1939 krb5_error_code
1940 decode_krb5_ad_signedpath(const krb5_data *, krb5_ad_signedpath **);
1941
1942 struct _krb5_key_data;          /* kdb.h */
1943
1944 struct ldap_seqof_key_data {
1945     krb5_int32 mkvno;           /* Master key version number */
1946     struct _krb5_key_data *key_data;
1947     krb5_int16 n_key_data;
1948 };
1949 typedef struct ldap_seqof_key_data ldap_seqof_key_data;
1950
1951 krb5_error_code
1952 krb5int_ldap_encode_sequence_of_keys(const ldap_seqof_key_data *val,
1953                                      krb5_data **code);
1954
1955 krb5_error_code
1956 krb5int_ldap_decode_sequence_of_keys(krb5_data *in,
1957                                      ldap_seqof_key_data **rep);
1958
1959 /*************************************************************************
1960  * End of prototypes for krb5_decode.c
1961  *************************************************************************/
1962
1963 #endif /* KRB5_ASN1__ */
1964 /*
1965  * End "asn1.h"
1966  */
1967
1968
1969 /*
1970  * Internal krb5 library routines
1971  */
1972 krb5_error_code
1973 krb5_encrypt_tkt_part(krb5_context, const krb5_keyblock *, krb5_ticket *);
1974
1975 krb5_error_code
1976 krb5_encode_kdc_rep(krb5_context, krb5_msgtype, const krb5_enc_kdc_rep_part *,
1977                     int using_subkey, const krb5_keyblock *, krb5_kdc_rep *,
1978                     krb5_data ** );
1979
1980 krb5_boolean
1981 krb5int_auth_con_chkseqnum(krb5_context ctx, krb5_auth_context ac,
1982                            krb5_ui_4 in_seq);
1983 /*
1984  * [De]Serialization Handle and operations.
1985  */
1986 struct __krb5_serializer {
1987     krb5_magic          odtype;
1988     krb5_error_code     (*sizer) (krb5_context,
1989                                   krb5_pointer,
1990                                   size_t *);
1991     krb5_error_code     (*externalizer) (krb5_context,
1992                                          krb5_pointer,
1993                                          krb5_octet **,
1994                                          size_t *);
1995     krb5_error_code     (*internalizer) (krb5_context,
1996                                          krb5_pointer *,
1997                                          krb5_octet **,
1998                                          size_t *);
1999 };
2000 typedef const struct __krb5_serializer * krb5_ser_handle;
2001 typedef struct __krb5_serializer krb5_ser_entry;
2002
2003 krb5_ser_handle krb5_find_serializer(krb5_context, krb5_magic);
2004 krb5_error_code krb5_register_serializer(krb5_context, const krb5_ser_entry *);
2005
2006 /* Determine the external size of a particular opaque structure */
2007 krb5_error_code KRB5_CALLCONV
2008 krb5_size_opaque(krb5_context, krb5_magic, krb5_pointer, size_t *);
2009
2010 /* Serialize the structure into a buffer */
2011 krb5_error_code KRB5_CALLCONV
2012 krb5_externalize_opaque(krb5_context, krb5_magic, krb5_pointer, krb5_octet **,
2013                         size_t *);
2014
2015 /* Deserialize the structure from a buffer */
2016 krb5_error_code KRB5_CALLCONV
2017 krb5_internalize_opaque(krb5_context, krb5_magic, krb5_pointer *,
2018                         krb5_octet **, size_t *);
2019
2020 /* Serialize data into a buffer */
2021 krb5_error_code
2022 krb5_externalize_data(krb5_context, krb5_pointer, krb5_octet **, size_t *);
2023 /*
2024  * Initialization routines.
2025  */
2026
2027 /* Initialize serialization for krb5_[os_]context */
2028 krb5_error_code KRB5_CALLCONV krb5_ser_context_init(krb5_context);
2029
2030 /* Initialize serialization for krb5_auth_context */
2031 krb5_error_code KRB5_CALLCONV krb5_ser_auth_context_init(krb5_context);
2032
2033 /* Initialize serialization for krb5_keytab */
2034 krb5_error_code KRB5_CALLCONV krb5_ser_keytab_init(krb5_context);
2035
2036 /* Initialize serialization for krb5_ccache */
2037 krb5_error_code KRB5_CALLCONV krb5_ser_ccache_init(krb5_context);
2038
2039 /* Initialize serialization for krb5_rcache */
2040 krb5_error_code KRB5_CALLCONV krb5_ser_rcache_init(krb5_context);
2041
2042 /* [De]serialize 4-byte integer */
2043 krb5_error_code KRB5_CALLCONV
2044 krb5_ser_pack_int32(krb5_int32, krb5_octet **, size_t *);
2045
2046 krb5_error_code KRB5_CALLCONV
2047 krb5_ser_unpack_int32(krb5_int32 *, krb5_octet **, size_t *);
2048
2049 /* [De]serialize 8-byte integer */
2050 krb5_error_code KRB5_CALLCONV
2051 krb5_ser_pack_int64(krb5_int64, krb5_octet **, size_t *);
2052
2053 krb5_error_code KRB5_CALLCONV
2054 krb5_ser_unpack_int64(krb5_int64 *, krb5_octet **, size_t *);
2055
2056 /* [De]serialize byte string */
2057 krb5_error_code KRB5_CALLCONV
2058 krb5_ser_pack_bytes(krb5_octet *, size_t, krb5_octet **, size_t *);
2059
2060 krb5_error_code KRB5_CALLCONV
2061 krb5_ser_unpack_bytes(krb5_octet *, size_t, krb5_octet **, size_t *);
2062
2063 krb5_error_code KRB5_CALLCONV
2064 krb5int_cc_default(krb5_context, krb5_ccache *);
2065
2066 krb5_error_code KRB5_CALLCONV
2067 krb5_cc_retrieve_cred_default(krb5_context, krb5_ccache, krb5_flags,
2068                               krb5_creds *, krb5_creds *);
2069
2070 krb5_boolean KRB5_CALLCONV
2071 krb5_creds_compare(krb5_context in_context, krb5_creds *in_creds,
2072                    krb5_creds *in_compare_creds);
2073
2074 void
2075 krb5int_set_prompt_types(krb5_context, krb5_prompt_type *);
2076
2077 krb5_error_code
2078 krb5int_generate_and_save_subkey(krb5_context, krb5_auth_context,
2079                                  krb5_keyblock * /* Old keyblock, not new!  */,
2080                                  krb5_enctype);
2081
2082 /* set and change password helpers */
2083
2084 krb5_error_code
2085 krb5int_mk_chpw_req(krb5_context context, krb5_auth_context auth_context,
2086                     krb5_data *ap_req, char *passwd, krb5_data *packet);
2087
2088 krb5_error_code
2089 krb5int_rd_chpw_rep(krb5_context context, krb5_auth_context auth_context,
2090                     krb5_data *packet, int *result_code,
2091                     krb5_data *result_data);
2092
2093 krb5_error_code KRB5_CALLCONV
2094 krb5_chpw_result_code_string(krb5_context context, int result_code,
2095                              char **result_codestr);
2096
2097 krb5_error_code
2098 krb5int_mk_setpw_req(krb5_context context, krb5_auth_context auth_context,
2099                      krb5_data *ap_req, krb5_principal targetprinc,
2100                      char *passwd, krb5_data *packet);
2101
2102 krb5_error_code
2103 krb5int_rd_setpw_rep(krb5_context context, krb5_auth_context auth_context,
2104                      krb5_data *packet, int *result_code,
2105                      krb5_data *result_data);
2106
2107 krb5_error_code
2108 krb5int_setpw_result_code_string(krb5_context context, int result_code,
2109                                  const char **result_codestr);
2110
2111 struct srv_dns_entry {
2112     struct srv_dns_entry *next;
2113     int priority;
2114     int weight;
2115     unsigned short port;
2116     char *host;
2117 };
2118 #ifdef KRB5_DNS_LOOKUP
2119
2120 #define MAX_DNS_NAMELEN (15*(MAXHOSTNAMELEN + 1)+1)
2121
2122 krb5_error_code
2123 krb5int_make_srv_query_realm(const krb5_data *realm,
2124                              const char *service,
2125                              const char *protocol,
2126                              struct srv_dns_entry **answers);
2127 void krb5int_free_srv_dns_data(struct srv_dns_entry *);
2128 #endif
2129
2130 /* value to use when requesting a keytab entry and KVNO doesn't matter */
2131 #define IGNORE_VNO 0
2132 /* value to use when requesting a keytab entry and enctype doesn't matter */
2133 #define IGNORE_ENCTYPE 0
2134
2135 /*
2136  * Convenience function for structure magic number
2137  */
2138 #define KRB5_VERIFY_MAGIC(structure,magic_number)                       \
2139     if ((structure)->magic != (magic_number)) return (magic_number);
2140
2141 /* to keep lint happy */
2142 #define krb5_xfree(val) free((char *)(val))
2143
2144 /* To keep happy libraries which are (for now) accessing internal stuff */
2145
2146 /* Make sure to increment by one when changing the struct */
2147 #define KRB5INT_ACCESS_STRUCT_VERSION 16
2148
2149 #ifndef ANAME_SZ
2150 struct ktext;                   /* from krb.h, for krb524 support */
2151 #endif
2152 typedef struct _krb5int_access {
2153     /* crypto stuff */
2154     krb5_error_code (*arcfour_gsscrypt)(const krb5_keyblock *keyblock,
2155                                         krb5_keyusage usage,
2156                                         const krb5_data *kd_data,
2157                                         krb5_crypto_iov *data,
2158                                         size_t num_data);
2159
2160     krb5_error_code (*auth_con_get_subkey_enctype)(krb5_context,
2161                                                    krb5_auth_context,
2162                                                    krb5_enctype *);
2163     /* service location and communication */
2164     krb5_error_code (*sendto_udp)(krb5_context, const krb5_data *msg,
2165                                   const struct addrlist *,
2166                                   struct sendto_callback_info *,
2167                                   krb5_data *reply, struct sockaddr *,
2168                                   socklen_t *, struct sockaddr *,
2169                                   socklen_t *, int *,
2170                                   int (*msg_handler)(krb5_context,
2171                                                      const krb5_data *,
2172                                                      void *),
2173                                   void *msg_handler_data);
2174     krb5_error_code (*add_host_to_list)(struct addrlist *lp,
2175                                         const char *hostname,
2176                                         int port, int secport,
2177                                         int socktype, int family);
2178     void (*free_addrlist)(struct addrlist *);
2179
2180     krb5_error_code (*make_srv_query_realm)(const krb5_data *realm,
2181                                             const char *service,
2182                                             const char *protocol,
2183                                             struct srv_dns_entry **answers);
2184     void (*free_srv_dns_data)(struct srv_dns_entry *);
2185     int (*use_dns_kdc)(krb5_context);
2186     krb5_error_code (*clean_hostname)(krb5_context, const char *, char *,
2187                                       size_t);
2188
2189     krb5_error_code (*mandatory_cksumtype)(krb5_context, krb5_enctype,
2190                                            krb5_cksumtype *);
2191     krb5_error_code (KRB5_CALLCONV *ser_pack_int64)(krb5_int64, krb5_octet **,
2192                                                     size_t *);
2193     krb5_error_code (KRB5_CALLCONV *ser_unpack_int64)(krb5_int64 *,
2194                                                       krb5_octet **, size_t *);
2195
2196     /* Used for KDB LDAP back end.  */
2197     krb5_error_code
2198     (*asn1_ldap_encode_sequence_of_keys)(const ldap_seqof_key_data *val,
2199                                          krb5_data **code);
2200
2201     krb5_error_code
2202     (*asn1_ldap_decode_sequence_of_keys)(krb5_data *in,
2203                                          ldap_seqof_key_data **);
2204
2205     /* Used for encrypted challenge fast factor*/
2206     krb5_error_code (*encode_enc_data)(const krb5_enc_data *, krb5_data **);
2207     krb5_error_code (*decode_enc_data)(const krb5_data *, krb5_enc_data **);
2208     void (*free_enc_data)(krb5_context, krb5_enc_data *);
2209     krb5_error_code (*encode_enc_ts)(const krb5_pa_enc_ts *, krb5_data **);
2210     krb5_error_code (*decode_enc_ts)(const krb5_data *, krb5_pa_enc_ts **);
2211     void (*free_enc_ts)(krb5_context, krb5_pa_enc_ts *);
2212     krb5_error_code
2213     (*encrypt_helper)(krb5_context, const krb5_keyblock *, krb5_keyusage,
2214                       const krb5_data *, krb5_enc_data *);
2215
2216     /*
2217      * pkinit asn.1 encode/decode functions
2218      */
2219     krb5_error_code
2220     (*encode_krb5_auth_pack)(const krb5_auth_pack *rep, krb5_data **code);
2221
2222     krb5_error_code
2223     (*encode_krb5_auth_pack_draft9)(const krb5_auth_pack_draft9 *rep,
2224                                     krb5_data **code);
2225
2226     krb5_error_code
2227     (*encode_krb5_kdc_dh_key_info)(const krb5_kdc_dh_key_info *rep,
2228                                    krb5_data **code);
2229
2230     krb5_error_code
2231     (*encode_krb5_pa_pk_as_rep)(const krb5_pa_pk_as_rep *rep,
2232                                 krb5_data **code);
2233
2234     krb5_error_code
2235     (*encode_krb5_pa_pk_as_rep_draft9)(const krb5_pa_pk_as_rep_draft9 *rep,
2236                                        krb5_data **code);
2237
2238     krb5_error_code
2239     (*encode_krb5_pa_pk_as_req)(const krb5_pa_pk_as_req *rep,
2240                                 krb5_data **code);
2241
2242     krb5_error_code
2243     (*encode_krb5_pa_pk_as_req_draft9)(const krb5_pa_pk_as_req_draft9 *rep,
2244                                        krb5_data **code);
2245
2246     krb5_error_code
2247     (*encode_krb5_reply_key_pack)(const krb5_reply_key_pack *,
2248                                   krb5_data **code);
2249
2250     krb5_error_code
2251     (*encode_krb5_reply_key_pack_draft9)(const krb5_reply_key_pack_draft9 *,
2252                                          krb5_data **code);
2253
2254     krb5_error_code
2255     (*encode_krb5_td_dh_parameters)(const krb5_algorithm_identifier **,
2256                                     krb5_data **code);
2257
2258     krb5_error_code
2259     (*encode_krb5_td_trusted_certifiers)(const
2260                                          krb5_external_principal_identifier **,
2261                                          krb5_data **code);
2262
2263     krb5_error_code
2264     (*encode_krb5_typed_data)(const krb5_typed_data **, krb5_data **code);
2265
2266     krb5_error_code
2267     (*decode_krb5_auth_pack)(const krb5_data *, krb5_auth_pack **);
2268
2269     krb5_error_code
2270     (*decode_krb5_auth_pack_draft9)(const krb5_data *,
2271                                     krb5_auth_pack_draft9 **);
2272
2273     krb5_error_code
2274     (*decode_krb5_pa_pk_as_req)(const krb5_data *, krb5_pa_pk_as_req **);
2275
2276     krb5_error_code
2277     (*decode_krb5_pa_pk_as_req_draft9)(const krb5_data *,
2278                                        krb5_pa_pk_as_req_draft9 **);
2279
2280     krb5_error_code
2281     (*decode_krb5_pa_pk_as_rep)(const krb5_data *, krb5_pa_pk_as_rep **);
2282
2283     krb5_error_code
2284     (*decode_krb5_pa_pk_as_rep_draft9)(const krb5_data *,
2285                                        krb5_pa_pk_as_rep_draft9 **);
2286
2287     krb5_error_code
2288     (*decode_krb5_kdc_dh_key_info)(const krb5_data *, krb5_kdc_dh_key_info **);
2289
2290     krb5_error_code
2291     (*decode_krb5_principal_name)(const krb5_data *, krb5_principal_data **);
2292
2293     krb5_error_code
2294     (*decode_krb5_reply_key_pack)(const krb5_data *, krb5_reply_key_pack **);
2295
2296     krb5_error_code
2297     (*decode_krb5_reply_key_pack_draft9)(const krb5_data *,
2298                                          krb5_reply_key_pack_draft9 **);
2299
2300     krb5_error_code
2301     (*decode_krb5_td_dh_parameters)(const krb5_data *,
2302                                     krb5_algorithm_identifier ***);
2303
2304     krb5_error_code
2305     (*decode_krb5_td_trusted_certifiers)(const krb5_data *,
2306                                          krb5_external_principal_identifier
2307                                          ***);
2308
2309     krb5_error_code
2310     (*decode_krb5_typed_data)(const krb5_data *, krb5_typed_data ***);
2311
2312     krb5_error_code
2313     (*decode_krb5_as_req)(const krb5_data *output, krb5_kdc_req **rep);
2314
2315     krb5_error_code
2316     (*encode_krb5_kdc_req_body)(const krb5_kdc_req *rep, krb5_data **code);
2317
2318     void
2319     (KRB5_CALLCONV *free_kdc_req)(krb5_context, krb5_kdc_req * );
2320     void
2321     (*set_prompt_types)(krb5_context, krb5_prompt_type *);
2322
2323     krb5_error_code
2324     (*encode_krb5_authdata_elt)(const krb5_authdata *rep, krb5_data **code);
2325
2326     /* Exported for testing only!  */
2327     krb5_error_code
2328     (*encode_krb5_sam_response_2)(const krb5_sam_response_2 *rep,
2329                                   krb5_data **code);
2330     krb5_error_code
2331     (*encode_krb5_enc_sam_response_enc_2)(const
2332                                           krb5_enc_sam_response_enc_2 *rep,
2333                                           krb5_data **code);
2334 } krb5int_access;
2335
2336 #define KRB5INT_ACCESS_VERSION                                          \
2337     (((krb5_int32)((sizeof(krb5int_access) & 0xFFFF) |                  \
2338                    (KRB5INT_ACCESS_STRUCT_VERSION << 16))) & 0xFFFFFFFF)
2339
2340 krb5_error_code KRB5_CALLCONV
2341 krb5int_accessor(krb5int_access*, krb5_int32);
2342
2343 /* Ick -- some krb524 and krb4 support placed in the krb5 library,
2344    because AFS (and potentially other applications?) use the krb4
2345    object as an opaque token, which (in some implementations) is not
2346    in fact a krb4 ticket, so we don't want to drag in the krb4 support
2347    just to enable this.  */
2348
2349 #define KRB524_SERVICE "krb524"
2350 #define KRB524_PORT 4444
2351
2352 /* temporary -- this should be under lib/krb5/ccache somewhere */
2353
2354 struct _krb5_ccache {
2355     krb5_magic magic;
2356     const struct _krb5_cc_ops *ops;
2357     krb5_pointer data;
2358 };
2359
2360 /*
2361  * Per-type ccache cursor.
2362  */
2363 struct krb5_cc_ptcursor_s {
2364     const struct _krb5_cc_ops *ops;
2365     krb5_pointer data;
2366 };
2367 typedef struct krb5_cc_ptcursor_s *krb5_cc_ptcursor;
2368
2369 struct _krb5_cc_ops {
2370     krb5_magic magic;
2371     char *prefix;
2372     const char * (KRB5_CALLCONV *get_name)(krb5_context, krb5_ccache);
2373     krb5_error_code (KRB5_CALLCONV *resolve)(krb5_context, krb5_ccache *,
2374                                              const char *);
2375     krb5_error_code (KRB5_CALLCONV *gen_new)(krb5_context, krb5_ccache *);
2376     krb5_error_code (KRB5_CALLCONV *init)(krb5_context, krb5_ccache,
2377                                           krb5_principal);
2378     krb5_error_code (KRB5_CALLCONV *destroy)(krb5_context, krb5_ccache);
2379     krb5_error_code (KRB5_CALLCONV *close)(krb5_context, krb5_ccache);
2380     krb5_error_code (KRB5_CALLCONV *store)(krb5_context, krb5_ccache,
2381                                            krb5_creds *);
2382     krb5_error_code (KRB5_CALLCONV *retrieve)(krb5_context, krb5_ccache,
2383                                               krb5_flags, krb5_creds *,
2384                                               krb5_creds *);
2385     krb5_error_code (KRB5_CALLCONV *get_princ)(krb5_context, krb5_ccache,
2386                                                krb5_principal *);
2387     krb5_error_code (KRB5_CALLCONV *get_first)(krb5_context, krb5_ccache,
2388                                                krb5_cc_cursor *);
2389     krb5_error_code (KRB5_CALLCONV *get_next)(krb5_context, krb5_ccache,
2390                                               krb5_cc_cursor *, krb5_creds *);
2391     krb5_error_code (KRB5_CALLCONV *end_get)(krb5_context, krb5_ccache,
2392                                              krb5_cc_cursor *);
2393     krb5_error_code (KRB5_CALLCONV *remove_cred)(krb5_context, krb5_ccache,
2394                                                  krb5_flags, krb5_creds *);
2395     krb5_error_code (KRB5_CALLCONV *set_flags)(krb5_context, krb5_ccache,
2396                                                krb5_flags);
2397     krb5_error_code (KRB5_CALLCONV *get_flags)(krb5_context, krb5_ccache,
2398                                                krb5_flags *);
2399     krb5_error_code (KRB5_CALLCONV *ptcursor_new)(krb5_context,
2400                                                   krb5_cc_ptcursor *);
2401     krb5_error_code (KRB5_CALLCONV *ptcursor_next)(krb5_context,
2402                                                    krb5_cc_ptcursor,
2403                                                    krb5_ccache *);
2404     krb5_error_code (KRB5_CALLCONV *ptcursor_free)(krb5_context,
2405                                                    krb5_cc_ptcursor *);
2406     krb5_error_code (KRB5_CALLCONV *move)(krb5_context, krb5_ccache,
2407                                           krb5_ccache);
2408     krb5_error_code (KRB5_CALLCONV *lastchange)(krb5_context,
2409                                                 krb5_ccache, krb5_timestamp *);
2410     krb5_error_code (KRB5_CALLCONV *wasdefault)(krb5_context, krb5_ccache,
2411                                                 krb5_timestamp *);
2412     krb5_error_code (KRB5_CALLCONV *lock)(krb5_context, krb5_ccache);
2413     krb5_error_code (KRB5_CALLCONV *unlock)(krb5_context, krb5_ccache);
2414 };
2415
2416 extern const krb5_cc_ops *krb5_cc_dfl_ops;
2417
2418 krb5_error_code
2419 krb5int_cc_os_default_name(krb5_context context, char **name);
2420
2421 typedef struct _krb5_donot_replay {
2422     krb5_magic magic;
2423     krb5_ui_4 hash;
2424     char *server;                       /* null-terminated */
2425     char *client;                       /* null-terminated */
2426     char *msghash;                      /* null-terminated */
2427     krb5_int32 cusec;
2428     krb5_timestamp ctime;
2429 } krb5_donot_replay;
2430
2431 krb5_error_code krb5_rc_default(krb5_context, krb5_rcache *);
2432 krb5_error_code krb5_rc_resolve_type(krb5_context, krb5_rcache *,char *);
2433 krb5_error_code krb5_rc_resolve_full(krb5_context, krb5_rcache *,char *);
2434 char *krb5_rc_get_type(krb5_context, krb5_rcache);
2435 char *krb5_rc_default_type(krb5_context);
2436 char *krb5_rc_default_name(krb5_context);
2437 krb5_error_code krb5_auth_to_rep(krb5_context, krb5_tkt_authent *,
2438                                  krb5_donot_replay *);
2439 krb5_error_code krb5_rc_hash_message(krb5_context context,
2440                                      const krb5_data *message, char **out);
2441
2442 krb5_error_code KRB5_CALLCONV
2443 krb5_rc_initialize(krb5_context, krb5_rcache, krb5_deltat);
2444
2445 krb5_error_code KRB5_CALLCONV
2446 krb5_rc_recover_or_initialize(krb5_context, krb5_rcache,krb5_deltat);
2447
2448 krb5_error_code KRB5_CALLCONV
2449 krb5_rc_recover(krb5_context, krb5_rcache);
2450
2451 krb5_error_code KRB5_CALLCONV
2452 krb5_rc_destroy(krb5_context, krb5_rcache);
2453
2454 krb5_error_code KRB5_CALLCONV
2455 krb5_rc_close(krb5_context, krb5_rcache);
2456
2457 krb5_error_code KRB5_CALLCONV
2458 krb5_rc_store(krb5_context, krb5_rcache, krb5_donot_replay *);
2459
2460 krb5_error_code KRB5_CALLCONV
2461 krb5_rc_expunge(krb5_context, krb5_rcache);
2462
2463 krb5_error_code KRB5_CALLCONV
2464 krb5_rc_get_lifespan(krb5_context, krb5_rcache,krb5_deltat *);
2465
2466 char *KRB5_CALLCONV
2467 krb5_rc_get_name(krb5_context, krb5_rcache);
2468
2469 krb5_error_code KRB5_CALLCONV
2470 krb5_rc_resolve(krb5_context, krb5_rcache, char *);
2471
2472 /*
2473  * This structure was exposed and used in macros in krb5 1.2, so do not
2474  * change its ABI.
2475  */
2476 typedef struct _krb5_kt_ops {
2477     krb5_magic magic;
2478     char *prefix;
2479
2480     /* routines always present */
2481     krb5_error_code (KRB5_CALLCONV *resolve)(krb5_context, const char *,
2482                                              krb5_keytab *);
2483     krb5_error_code (KRB5_CALLCONV *get_name)(krb5_context, krb5_keytab,
2484                                               char *, unsigned int);
2485     krb5_error_code (KRB5_CALLCONV *close)(krb5_context, krb5_keytab);
2486     krb5_error_code (KRB5_CALLCONV *get)(krb5_context, krb5_keytab,
2487                                          krb5_const_principal, krb5_kvno,
2488                                          krb5_enctype, krb5_keytab_entry *);
2489     krb5_error_code (KRB5_CALLCONV *start_seq_get)(krb5_context, krb5_keytab,
2490                                                    krb5_kt_cursor *);
2491     krb5_error_code (KRB5_CALLCONV *get_next)(krb5_context, krb5_keytab,
2492                                               krb5_keytab_entry *,
2493                                               krb5_kt_cursor *);
2494     krb5_error_code (KRB5_CALLCONV *end_get)(krb5_context, krb5_keytab,
2495                                              krb5_kt_cursor *);
2496     /* routines to be included on extended version (write routines) */
2497     krb5_error_code (KRB5_CALLCONV *add)(krb5_context, krb5_keytab,
2498                                          krb5_keytab_entry *);
2499     krb5_error_code (KRB5_CALLCONV *remove)(krb5_context, krb5_keytab,
2500                                             krb5_keytab_entry *);
2501
2502     /* Handle for serializer */
2503     const krb5_ser_entry *serializer;
2504 } krb5_kt_ops;
2505
2506 extern const krb5_kt_ops krb5_kt_dfl_ops;
2507
2508 extern krb5_error_code krb5int_translate_gai_error(int);
2509
2510 /* Not sure it's ready for exposure just yet.  */
2511 extern krb5_error_code
2512 krb5int_c_mandatory_cksumtype(krb5_context, krb5_enctype, krb5_cksumtype *);
2513
2514 extern int krb5int_crypto_init (void);
2515 extern int krb5int_prng_init(void);
2516
2517 /*
2518  * Referral definitions, debugging hooks, and subfunctions.
2519  */
2520 #define        KRB5_REFERRAL_MAXHOPS    10
2521 /* #define DEBUG_REFERRALS */
2522
2523 #ifdef DEBUG_REFERRALS
2524 void krb5int_dbgref_dump_principal(char *, krb5_principal);
2525 #endif
2526
2527 /* Common hostname-parsing code. */
2528 krb5_error_code KRB5_CALLCONV
2529 krb5int_clean_hostname(krb5_context, const char *, char *, size_t);
2530
2531 krb5_error_code
2532 krb5int_aes_encrypt(krb5_key key, const krb5_data *ivec, krb5_crypto_iov *data,
2533                     size_t num_data);
2534
2535 krb5_error_code
2536 krb5int_aes_decrypt(krb5_key key, const krb5_data *ivec, krb5_crypto_iov *data,
2537                     size_t num_data);
2538
2539 struct _krb5_kt {       /* should move into k5-int.h */
2540     krb5_magic magic;
2541     const struct _krb5_kt_ops *ops;
2542     krb5_pointer data;
2543 };
2544
2545 krb5_error_code krb5_set_default_in_tkt_ktypes(krb5_context,
2546                                                const krb5_enctype *);
2547
2548 krb5_error_code krb5_get_default_in_tkt_ktypes(krb5_context, krb5_enctype **);
2549
2550 krb5_error_code krb5_set_default_tgs_ktypes(krb5_context,
2551                                             const krb5_enctype *);
2552
2553 krb5_error_code KRB5_CALLCONV
2554 krb5_get_tgs_ktypes(krb5_context, krb5_const_principal, krb5_enctype **);
2555
2556 void KRB5_CALLCONV krb5_free_ktypes(krb5_context, krb5_enctype *);
2557
2558 krb5_boolean krb5_is_permitted_enctype(krb5_context, krb5_enctype);
2559
2560 typedef struct
2561 {
2562     krb5_enctype *etype;
2563     krb5_boolean *etype_ok;
2564     krb5_int32 etype_count;
2565 } krb5_etypes_permitted;
2566
2567 krb5_boolean krb5_is_permitted_enctype_ext(krb5_context,
2568                                            krb5_etypes_permitted *);
2569
2570 krb5_boolean KRB5_CALLCONV krb5int_c_weak_enctype(krb5_enctype);
2571
2572 krb5_error_code krb5_kdc_rep_decrypt_proc(krb5_context, const krb5_keyblock *,
2573                                           krb5_const_pointer, krb5_kdc_rep *);
2574 krb5_error_code KRB5_CALLCONV krb5_decrypt_tkt_part(krb5_context,
2575                                                     const krb5_keyblock *,
2576                                                     krb5_ticket * );
2577 krb5_error_code krb5_get_cred_from_kdc(krb5_context, krb5_ccache,
2578                                        krb5_creds *, krb5_creds **,
2579                                        krb5_creds *** );
2580 krb5_error_code krb5_get_cred_from_kdc_validate(krb5_context, krb5_ccache,
2581                                                 krb5_creds *, krb5_creds **,
2582                                                 krb5_creds *** );
2583 krb5_error_code krb5_get_cred_from_kdc_renew(krb5_context, krb5_ccache,
2584                                              krb5_creds *, krb5_creds **,
2585                                              krb5_creds *** );
2586
2587 krb5_error_code krb5_get_cred_via_tkt(krb5_context, krb5_creds *, krb5_flags,
2588                                       krb5_address *const *, krb5_creds *,
2589                                       krb5_creds **);
2590
2591 krb5_error_code KRB5_CALLCONV krb5_copy_addr(krb5_context,
2592                                              const krb5_address *,
2593                                              krb5_address **);
2594
2595 void krb5_init_ets(krb5_context);
2596 void krb5_free_ets(krb5_context);
2597 krb5_error_code krb5_generate_subkey(krb5_context, const krb5_keyblock *,
2598                                      krb5_keyblock **);
2599 krb5_error_code krb5_generate_subkey_extended(krb5_context,
2600                                               const krb5_keyblock *,
2601                                               krb5_enctype, krb5_keyblock **);
2602 krb5_error_code krb5_generate_seq_number(krb5_context, const krb5_keyblock *,
2603                                          krb5_ui_4 *);
2604
2605 krb5_error_code KRB5_CALLCONV krb5_kt_register(krb5_context,
2606                                                const struct _krb5_kt_ops *);
2607
2608 krb5_error_code krb5_principal2salt_norealm(krb5_context, krb5_const_principal,
2609                                             krb5_data *);
2610
2611 unsigned int KRB5_CALLCONV krb5_get_notification_message(void);
2612
2613 /* chk_trans.c */
2614 krb5_error_code krb5_check_transited_list(krb5_context, const krb5_data *trans,
2615                                           const krb5_data *realm1,
2616                                           const krb5_data *realm2);
2617
2618 /* free_rtree.c */
2619 void krb5_free_realm_tree(krb5_context, krb5_principal *);
2620
2621 void KRB5_CALLCONV krb5_free_authenticator_contents(krb5_context,
2622                                                     krb5_authenticator *);
2623
2624 void KRB5_CALLCONV krb5_free_address(krb5_context, krb5_address *);
2625
2626 void KRB5_CALLCONV krb5_free_enc_tkt_part(krb5_context, krb5_enc_tkt_part *);
2627
2628 void KRB5_CALLCONV krb5_free_tickets(krb5_context, krb5_ticket **);
2629 void KRB5_CALLCONV krb5_free_kdc_req(krb5_context, krb5_kdc_req *);
2630 void KRB5_CALLCONV krb5_free_kdc_rep(krb5_context, krb5_kdc_rep *);
2631 void KRB5_CALLCONV krb5_free_last_req(krb5_context, krb5_last_req_entry **);
2632 void KRB5_CALLCONV krb5_free_enc_kdc_rep_part(krb5_context,
2633                                               krb5_enc_kdc_rep_part *);
2634 void KRB5_CALLCONV krb5_free_ap_req(krb5_context, krb5_ap_req *);
2635 void KRB5_CALLCONV krb5_free_ap_rep(krb5_context, krb5_ap_rep *);
2636 void KRB5_CALLCONV krb5_free_cred(krb5_context, krb5_cred *);
2637 void KRB5_CALLCONV krb5_free_cred_enc_part(krb5_context, krb5_cred_enc_part *);
2638 void KRB5_CALLCONV krb5_free_pa_data(krb5_context, krb5_pa_data **);
2639 void KRB5_CALLCONV krb5_free_tkt_authent(krb5_context, krb5_tkt_authent *);
2640 void KRB5_CALLCONV krb5_free_pwd_data(krb5_context, krb5_pwd_data *);
2641 void KRB5_CALLCONV krb5_free_pwd_sequences(krb5_context,
2642                                            passwd_phrase_element **);
2643 void KRB5_CALLCONV krb5_free_passwd_phrase_element(krb5_context,
2644                                                    passwd_phrase_element *);
2645 void KRB5_CALLCONV krb5_free_alt_method(krb5_context, krb5_alt_method *);
2646 void KRB5_CALLCONV krb5_free_enc_data(krb5_context, krb5_enc_data *);
2647 krb5_error_code krb5_set_config_files(krb5_context, const char **);
2648
2649 krb5_error_code KRB5_CALLCONV krb5_get_default_config_files(char ***filenames);
2650
2651 void KRB5_CALLCONV krb5_free_config_files(char **filenames);
2652
2653 krb5_error_code krb5int_find_authdata(krb5_context context,
2654                                       krb5_authdata *const *ticket_authdata,
2655                                       krb5_authdata *const *ap_req_authdata,
2656                                       krb5_authdatatype ad_type,
2657                                       krb5_authdata ***results);
2658
2659 krb5_error_code krb5_rd_req_decoded(krb5_context, krb5_auth_context *,
2660                                     const krb5_ap_req *, krb5_const_principal,
2661                                     krb5_keytab, krb5_flags *, krb5_ticket **);
2662
2663 krb5_error_code krb5_rd_req_decoded_anyflag(krb5_context, krb5_auth_context *,
2664                                             const krb5_ap_req *,
2665                                             krb5_const_principal, krb5_keytab,
2666                                             krb5_flags *, krb5_ticket **);
2667
2668 krb5_error_code KRB5_CALLCONV
2669 krb5_cc_register(krb5_context, const krb5_cc_ops *, krb5_boolean );
2670
2671 krb5_error_code krb5_walk_realm_tree(krb5_context, const krb5_data *,
2672                                      const krb5_data *, krb5_principal **,
2673                                      int);
2674
2675 krb5_error_code
2676 krb5_auth_con_set_safe_cksumtype(krb5_context, krb5_auth_context,
2677                                  krb5_cksumtype);
2678
2679 krb5_error_code krb5_auth_con_setivector(krb5_context, krb5_auth_context,
2680                                          krb5_pointer);
2681
2682 krb5_error_code krb5_auth_con_getivector(krb5_context, krb5_auth_context,
2683                                          krb5_pointer *);
2684
2685 krb5_error_code krb5_auth_con_setpermetypes(krb5_context, krb5_auth_context,
2686                                             const krb5_enctype *);
2687
2688 krb5_error_code krb5_auth_con_getpermetypes(krb5_context, krb5_auth_context,
2689                                             krb5_enctype **);
2690
2691 krb5_error_code krb5_auth_con_get_subkey_enctype(krb5_context context,
2692                                                  krb5_auth_context,
2693                                                  krb5_enctype *);
2694
2695 krb5_error_code
2696 krb5_auth_con_get_authdata_context(krb5_context context,
2697                                    krb5_auth_context auth_context,
2698                                    krb5_authdata_context *ad_context);
2699
2700 krb5_error_code
2701 krb5_auth_con_set_authdata_context(krb5_context context,
2702                                    krb5_auth_context auth_context,
2703                                    krb5_authdata_context ad_context);
2704
2705 krb5_error_code KRB5_CALLCONV
2706 krb5int_server_decrypt_ticket_keyblock(krb5_context context,
2707                                        const krb5_keyblock *key,
2708                                        krb5_ticket  *ticket);
2709
2710 krb5_error_code krb5_read_message(krb5_context, krb5_pointer, krb5_data *);
2711 krb5_error_code krb5_write_message(krb5_context, krb5_pointer, krb5_data *);
2712 krb5_error_code krb5int_write_messages(krb5_context, krb5_pointer, krb5_data *,
2713                                        int);
2714 int krb5_net_read(krb5_context, int , char *, int);
2715 int krb5_net_write(krb5_context, int , const char *, int);
2716
2717 krb5_error_code KRB5_CALLCONV krb5_get_realm_domain(krb5_context,
2718                                                     const char *, char ** );
2719
2720 krb5_error_code krb5_gen_portaddr(krb5_context, const krb5_address *,
2721                                   krb5_const_pointer, krb5_address **);
2722
2723 krb5_error_code krb5_gen_replay_name(krb5_context, const krb5_address *,
2724                                      const char *, char **);
2725 krb5_error_code krb5_make_fulladdr(krb5_context, krb5_address *,
2726                                    krb5_address *, krb5_address *);
2727
2728 krb5_error_code krb5_set_debugging_time(krb5_context, krb5_timestamp,
2729                                         krb5_int32);
2730 krb5_error_code krb5_use_natural_time(krb5_context);
2731 krb5_error_code krb5_set_time_offsets(krb5_context, krb5_timestamp,
2732                                       krb5_int32);
2733 krb5_error_code krb5int_check_clockskew(krb5_context, krb5_timestamp);
2734 /*
2735  * The realm iterator functions
2736  */
2737
2738 krb5_error_code KRB5_CALLCONV
2739 krb5_realm_iterator_create(krb5_context context, void **iter_p);
2740
2741 krb5_error_code KRB5_CALLCONV
2742 krb5_realm_iterator(krb5_context context, void **iter_p, char **ret_realm);
2743
2744 void KRB5_CALLCONV
2745 krb5_realm_iterator_free(krb5_context context, void **iter_p);
2746
2747 void KRB5_CALLCONV krb5_free_realm_string(krb5_context context, char *str);
2748
2749 /* Internal principal function used by KIM to avoid code duplication */
2750 krb5_error_code KRB5_CALLCONV
2751 krb5int_build_principal_alloc_va(krb5_context context,
2752                                  krb5_principal *princ,
2753                                  unsigned int rlen,
2754                                  const char *realm,
2755                                  const char *first,
2756                                  va_list ap);
2757
2758 /* Some data comparison and conversion functions.  */
2759 static inline int
2760 data_eq(krb5_data d1, krb5_data d2)
2761 {
2762     return (d1.length == d2.length
2763             && !memcmp(d1.data, d2.data, d1.length));
2764 }
2765
2766 static inline krb5_data
2767 make_data(void *data, unsigned int len)
2768 {
2769     krb5_data d;
2770
2771     d.magic = KV5M_DATA;
2772     d.data = (char *) data;
2773     d.length = len;
2774     return d;
2775 }
2776
2777 static inline krb5_data
2778 empty_data()
2779 {
2780     return make_data(NULL, 0);
2781 }
2782
2783 static inline krb5_data
2784 string2data(char *str)
2785 {
2786     return make_data(str, strlen(str));
2787 }
2788
2789 static inline krb5_error_code
2790 alloc_data(krb5_data *data, unsigned int len)
2791 {
2792     /* Allocate at least one byte since zero-byte allocs may return NULL. */
2793     char *ptr = (char *) calloc((len > 0) ? len : 1, 1);
2794
2795     if (ptr == NULL)
2796         return ENOMEM;
2797     data->magic = KV5M_DATA;
2798     data->data = ptr;
2799     data->length = len;
2800     return 0;
2801 }
2802
2803 static inline int
2804 data_eq_string (krb5_data d, char *s)
2805 {
2806     return data_eq(d, string2data(s));
2807 }
2808
2809 static inline int
2810 authdata_eq(krb5_authdata a1, krb5_authdata a2)
2811 {
2812     return (a1.ad_type == a2.ad_type
2813             && a1.length == a2.length
2814             && !memcmp(a1.contents, a2.contents, a1.length));
2815 }
2816
2817 /* Allocate zeroed memory; set *code to 0 on success or ENOMEM on failure. */
2818 static inline void *
2819 k5alloc(size_t len, krb5_error_code *code)
2820 {
2821     void *ptr;
2822
2823     /* Allocate at least one byte since zero-byte allocs may return NULL. */
2824     ptr = calloc((len > 0) ? len : 1, 1);
2825     *code = (ptr == NULL) ? ENOMEM : 0;
2826     return ptr;
2827 }
2828
2829 krb5_error_code KRB5_CALLCONV
2830 krb5int_pac_sign(krb5_context context,
2831                  krb5_pac pac,
2832                  krb5_timestamp authtime,
2833                  krb5_const_principal principal,
2834                  const krb5_keyblock *server_key,
2835                  const krb5_keyblock *privsvr_key,
2836                  krb5_data *data);
2837
2838 krb5_error_code KRB5_CALLCONV
2839 krb5_get_credentials_for_user(krb5_context context, krb5_flags options,
2840                               krb5_ccache ccache,
2841                               krb5_creds *in_creds,
2842                               krb5_data *cert,
2843                               krb5_creds **out_creds);
2844
2845 krb5_error_code KRB5_CALLCONV
2846 krb5_get_credentials_for_proxy(krb5_context context,
2847                                krb5_flags options,
2848                                krb5_ccache ccache,
2849                                krb5_creds *in_creds,
2850                                krb5_ticket *evidence_tkt,
2851                                krb5_creds **out_creds);
2852
2853 krb5_error_code KRB5_CALLCONV
2854 krb5int_get_authdata_containee_types(krb5_context context,
2855                                      const krb5_authdata *container,
2856                                      unsigned int *nad_types,
2857                                      krb5_authdatatype **ad_types);
2858
2859 krb5_error_code krb5int_parse_enctype_list(krb5_context context, char *profstr,
2860                                            krb5_enctype *default_list,
2861                                            krb5_enctype **result);
2862
2863 #ifdef DEBUG_ERROR_LOCATIONS
2864 #define krb5_set_error_message(ctx, code, ...)                          \
2865     krb5_set_error_message_fl(ctx, code, __FILE__, __LINE__, __VA_ARGS__)
2866 #endif
2867
2868 #endif /* _KRB5_INT_H */