www.project-moonshot.org Git - mech_eap.orig/blob - mech_eap/util_sm.c

   1 /*
   2  * Copyright (c) 2011, JANET(UK)
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * 3. Neither the name of JANET(UK) nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /*
  34  * Context establishment state machine.
  35  */
  36
  37 #include "gssapiP_eap.h"
  38
  39 /* private flags */
  40 #define SM_FLAG_TRANSITED                   0x80000000
  41
  42 #define SM_ASSERT_VALID(ctx, status)        do { \
  43         GSSEAP_ASSERT(GSS_ERROR((status)) || \
  44                ((status) == GSS_S_CONTINUE_NEEDED && ((ctx)->state > GSSEAP_STATE_INITIAL && (ctx)->state < GSSEAP_STATE_ESTABLISHED)) || \
  45                ((status) == GSS_S_COMPLETE && (ctx)->state == GSSEAP_STATE_ESTABLISHED)); \
  46     } while (0)
  47
  48 #ifdef GSSEAP_DEBUG
  49 static const char *
  50 gssEapStateToString(enum gss_eap_state state)
  51 {
  52     const char *s;
  53
  54     switch (state) {
  55     case GSSEAP_STATE_INITIAL:
  56         s = "INITIAL";
  57         break;
  58     case GSSEAP_STATE_AUTHENTICATE:
  59         s = "AUTHENTICATE";
  60         break;
  61     case GSSEAP_STATE_INITIATOR_EXTS:
  62         s = "INITIATOR_EXTS";
  63         break;
  64     case GSSEAP_STATE_ACCEPTOR_EXTS:
  65         s = "ACCEPTOR_EXTS";
  66         break;
  67 #ifdef GSSEAP_ENABLE_REAUTH
  68     case GSSEAP_STATE_REAUTHENTICATE:
  69         s = "REAUTHENTICATE";
  70         break;
  71 #endif
  72     case GSSEAP_STATE_ESTABLISHED:
  73         s = "ESTABLISHED";
  74         break;
  75     default:
  76         s = "INVALID";
  77         break;
  78     }
  79
  80     return s;
  81 }
  82
  83 void
  84 gssEapSmTransition(gss_ctx_id_t ctx, enum gss_eap_state state)
  85 {
  86     GSSEAP_ASSERT(state >= GSSEAP_STATE_INITIAL);
  87     GSSEAP_ASSERT(state <= GSSEAP_STATE_ESTABLISHED);
  88
  89     fprintf(stderr, "GSS-EAP: state transition %s->%s\n",
  90             gssEapStateToString(GSSEAP_SM_STATE(ctx)),
  91             gssEapStateToString(state));
  92
  93     ctx->state = state;
  94 }
  95 #endif /* GSSEAP_DEBUG */
  96
  97 static OM_uint32
  98 makeErrorToken(OM_uint32 *minor,
  99                OM_uint32 majorStatus,
 100                OM_uint32 minorStatus,
 101                struct gss_eap_token_buffer_set *token)
 102 {
 103     OM_uint32 major, tmpMinor;
 104     unsigned char errorData[8];
 105     gss_buffer_desc errorBuffer;
 106
 107     GSSEAP_ASSERT(GSS_ERROR(majorStatus));
 108
 109     /*
 110      * Only return error codes that the initiator could have caused,
 111      * to avoid information leakage.
 112      */
 113     if (IS_RADIUS_ERROR(minorStatus)) {
 114         /* Squash RADIUS error codes */
 115         minorStatus = GSSEAP_RADIUS_PROT_FAILURE;
 116     } else if (!IS_WIRE_ERROR(minorStatus)) {
 117         /* Don't return non-wire error codes */
 118         return GSS_S_COMPLETE;
 119     }
 120
 121     minorStatus -= ERROR_TABLE_BASE_eapg;
 122
 123     store_uint32_be(majorStatus, &errorData[0]);
 124     store_uint32_be(minorStatus, &errorData[4]);
 125
 126     major = gssEapAllocInnerTokens(&tmpMinor, 1, token);
 127     if (GSS_ERROR(major)) {
 128         *minor = tmpMinor;
 129         return major;
 130     }
 131
 132     errorBuffer.length = sizeof(errorData);
 133     errorBuffer.value = errorData;
 134
 135     major = duplicateBuffer(&tmpMinor, &errorBuffer, &token->buffers.elements[0]);
 136     if (GSS_ERROR(major)) {
 137         gssEapReleaseInnerTokens(&tmpMinor, token, 1);
 138         *minor = tmpMinor;
 139         return major;
 140     }
 141
 142     token->types[0] = ITOK_TYPE_CONTEXT_ERR | ITOK_FLAG_CRITICAL;
 143
 144     *minor = 0;
 145     return GSS_S_COMPLETE;
 146 }
 147
 148 OM_uint32
 149 gssEapSmStep(OM_uint32 *minor,
 150              gss_cred_id_t cred,
 151              gss_ctx_id_t ctx,
 152              gss_name_t target,
 153              gss_OID mech,
 154              OM_uint32 reqFlags,
 155              OM_uint32 timeReq,
 156              gss_channel_bindings_t chanBindings,
 157              gss_buffer_t inputToken,
 158              gss_buffer_t outputToken,
 159              struct gss_eap_sm *sm, /* ordered by state */
 160              size_t smCount)
 161 {
 162     OM_uint32 major, tmpMajor, tmpMinor;
 163     struct gss_eap_token_buffer_set inputTokens = { { 0, GSS_C_NO_BUFFER }, NULL };
 164     struct gss_eap_token_buffer_set outputTokens = { { 0, GSS_C_NO_BUFFER }, NULL };
 165     gss_buffer_desc unwrappedInputToken = GSS_C_EMPTY_BUFFER;
 166     gss_buffer_desc unwrappedOutputToken = GSS_C_EMPTY_BUFFER;
 167     unsigned int smFlags = 0;
 168     size_t i, j;
 169     int initialContextToken = 0;
 170     enum gss_eap_token_type tokType;
 171
 172     GSSEAP_ASSERT(smCount > 0);
 173
 174     *minor = 0;
 175
 176     outputToken->length = 0;
 177     outputToken->value = NULL;
 178
 179     if (inputToken != GSS_C_NO_BUFFER && inputToken->length != 0) {
 180         major = gssEapVerifyToken(minor, ctx, inputToken, &tokType,
 181                                   &unwrappedInputToken);
 182         if (GSS_ERROR(major))
 183             goto cleanup;
 184
 185         if (tokType != (CTX_IS_INITIATOR(ctx)
 186                     ? TOK_TYPE_ACCEPTOR_CONTEXT : TOK_TYPE_INITIATOR_CONTEXT)) {
 187             major = GSS_S_DEFECTIVE_TOKEN;
 188             *minor = GSSEAP_WRONG_TOK_ID;
 189             goto cleanup;
 190         }
 191     } else if (!CTX_IS_INITIATOR(ctx) || ctx->state != GSSEAP_STATE_INITIAL) {
 192         major = GSS_S_DEFECTIVE_TOKEN;
 193         *minor = GSSEAP_WRONG_SIZE;
 194         goto cleanup;
 195     } else {
 196         initialContextToken = 1;
 197     }
 198
 199     if (CTX_IS_ESTABLISHED(ctx)) {
 200         major = GSS_S_BAD_STATUS;
 201         *minor = GSSEAP_CONTEXT_ESTABLISHED;
 202         goto cleanup;
 203     }
 204
 205     GSSEAP_ASSERT(ctx->state < GSSEAP_STATE_ESTABLISHED);
 206
 207     major = gssEapDecodeInnerTokens(minor, &unwrappedInputToken, &inputTokens);
 208     if (GSS_ERROR(major))
 209         goto cleanup;
 210
 211     major = gssEapAllocInnerTokens(minor, smCount, &outputTokens);
 212     if (GSS_ERROR(major))
 213         goto cleanup;
 214
 215     ctx->inputTokens = &inputTokens;
 216     ctx->outputTokens = &outputTokens;
 217
 218     /* Process all the tokens that are valid for the current state. */
 219     for (i = 0; i < smCount; i++) {
 220         struct gss_eap_sm *smp = &sm[i];
 221         int processToken = 0;
 222         gss_buffer_t innerInputToken = GSS_C_NO_BUFFER;
 223         OM_uint32 *inputTokenType = NULL;
 224         gss_buffer_desc innerOutputToken = GSS_C_EMPTY_BUFFER;
 225
 226         if ((smp->validStates & ctx->state) == 0)
 227             continue;
 228
 229         /*
 230          * We special case the first call to gss_init_sec_context so that
 231          * all token providers have the opportunity to generate an initial
 232          * context token. Providers where inputTokenType is ITOK_TYPE_NONE
 233          * are always called and generally act on state transition boundaries,
 234          * for example to advance the state after a series of optional tokens
 235          * (as is the case with the extension token exchange) or to generate
 236          * a new token after the state was advanced by a provider which did
 237          * not emit a token.
 238          */
 239         if (smp->inputTokenType == ITOK_TYPE_NONE || initialContextToken) {
 240             processToken = 1;
 241         } else if ((smFlags & SM_FLAG_TRANSITED) == 0) {
 242             /* Don't regurgitate a token which belonds to a previous state. */
 243             for (j = 0; j < inputTokens.buffers.count; j++) {
 244                 if ((inputTokens.types[j] & ITOK_TYPE_MASK) == smp->inputTokenType) {
 245                     if (processToken) {
 246                         /* Check for duplicate inner tokens */
 247                         major = GSS_S_DEFECTIVE_TOKEN;
 248                         *minor = GSSEAP_DUPLICATE_ITOK;
 249                         break;
 250                     }
 251                     processToken = 1;
 252                     innerInputToken = &inputTokens.buffers.elements[j];
 253                     inputTokenType = &inputTokens.types[j];
 254                 }
 255             }
 256             if (GSS_ERROR(major))
 257                 break;
 258         }
 259
 260         if (processToken) {
 261             enum gss_eap_state oldState = ctx->state;
 262
 263             smFlags = 0;
 264             if (inputTokenType != NULL && (*inputTokenType & ITOK_FLAG_CRITICAL))
 265                 smFlags |= SM_FLAG_INPUT_TOKEN_CRITICAL;
 266
 267             major = smp->processToken(minor, cred, ctx, target, mech, reqFlags,
 268                                       timeReq, chanBindings, innerInputToken,
 269                                       &innerOutputToken, &smFlags);
 270             if (GSS_ERROR(major))
 271                 break;
 272
 273             if (inputTokenType != NULL)
 274                 *inputTokenType |= ITOK_FLAG_VERIFIED;
 275             if (ctx->state < oldState)
 276                 i = 0; /* restart */
 277             else if (ctx->state != oldState)
 278                 smFlags |= SM_FLAG_TRANSITED;
 279
 280             if (innerOutputToken.value != NULL) {
 281                 outputTokens.buffers.elements[outputTokens.buffers.count] = innerOutputToken;
 282                 GSSEAP_ASSERT(smp->outputTokenType != ITOK_TYPE_NONE);
 283                 outputTokens.types[outputTokens.buffers.count] = smp->outputTokenType;
 284                 if (smFlags & SM_FLAG_OUTPUT_TOKEN_CRITICAL)
 285                     outputTokens.types[outputTokens.buffers.count] |= ITOK_FLAG_CRITICAL;
 286                 outputTokens.buffers.count++;
 287             }
 288             /*
 289              * Break out if we made a state transition and have some tokens to send.
 290              */
 291             if ((smFlags & SM_FLAG_TRANSITED) &&
 292                  ((smFlags & SM_FLAG_FORCE_SEND_TOKEN) || outputTokens.buffers.count != 0)) {
 293                 SM_ASSERT_VALID(ctx, major);
 294                 break;
 295             }
 296         } else if ((smp->itokFlags & SM_ITOK_FLAG_REQUIRED) &&
 297             smp->inputTokenType != ITOK_TYPE_NONE) {
 298             /* Check for required inner tokens */
 299             major = GSS_S_DEFECTIVE_TOKEN;
 300             *minor = GSSEAP_MISSING_REQUIRED_ITOK;
 301             break;
 302         }
 303     }
 304
 305     GSSEAP_ASSERT(outputTokens.buffers.count <= smCount);
 306
 307     /* Check we understood all critical tokens sent by peer */
 308     if (!GSS_ERROR(major)) {
 309         for (j = 0; j < inputTokens.buffers.count; j++) {
 310             if ((inputTokens.types[j] & ITOK_FLAG_CRITICAL) &&
 311                 (inputTokens.types[j] & ITOK_FLAG_VERIFIED) == 0) {
 312                 major = GSS_S_UNAVAILABLE;
 313                 *minor = GSSEAP_CRIT_ITOK_UNAVAILABLE;
 314                 goto cleanup;
 315             }
 316         }
 317     }
 318
 319     /* Optionaly emit an error token if we are the acceptor */
 320     if (GSS_ERROR(major)) {
 321         if (CTX_IS_INITIATOR(ctx))
 322             goto cleanup; /* return error directly to caller */
 323
 324         /* replace any emitted tokens with error token */
 325         gssEapReleaseInnerTokens(&tmpMinor, &outputTokens, 1);
 326
 327         tmpMajor = makeErrorToken(&tmpMinor, major, *minor, &outputTokens);
 328         if (GSS_ERROR(tmpMajor)) {
 329             major = tmpMajor;
 330             *minor = tmpMinor;
 331             goto cleanup;
 332         }
 333     }
 334
 335     /* Format output token from inner tokens */
 336     if (outputTokens.buffers.count != 0 ||            /* inner tokens to send */
 337         !CTX_IS_INITIATOR(ctx) ||                   /* any leg acceptor */
 338         !CTX_IS_ESTABLISHED(ctx)) {                 /* non-last leg initiator */
 339         tmpMajor = gssEapEncodeInnerTokens(&tmpMinor, &outputTokens, &unwrappedOutputToken);
 340         if (tmpMajor == GSS_S_COMPLETE) {
 341             if (CTX_IS_INITIATOR(ctx))
 342                 tokType = TOK_TYPE_INITIATOR_CONTEXT;
 343             else
 344                 tokType = TOK_TYPE_ACCEPTOR_CONTEXT;
 345
 346             tmpMajor = gssEapMakeToken(&tmpMinor, ctx, &unwrappedOutputToken,
 347                                        tokType, outputToken);
 348             if (GSS_ERROR(tmpMajor)) {
 349                 major = tmpMajor;
 350                 *minor = tmpMinor;
 351                 goto cleanup;
 352             }
 353         }
 354     }
 355
 356     /* If the context is established, empty tokens only to be emitted by initiator */
 357     GSSEAP_ASSERT(!CTX_IS_ESTABLISHED(ctx) || ((outputToken->length == 0) == CTX_IS_INITIATOR(ctx)));
 358
 359     SM_ASSERT_VALID(ctx, major);
 360
 361 cleanup:
 362     gssEapReleaseInnerTokens(&tmpMinor, &inputTokens, 0);
 363     gssEapReleaseInnerTokens(&tmpMinor, &inputTokens, 1);
 364
 365     gss_release_buffer(&tmpMinor, &unwrappedOutputToken);
 366
 367     ctx->inputTokens = NULL;
 368     ctx->outputTokens = NULL;
 369
 370     return major;
 371 }