/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */

/* plugins/gssapi/negoextest/main.c - GSS test module for NegoEx */

/*

 * Copyright (C) 2019 by the Massachusetts Institute of Technology.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * * Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 *

 * * Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in

 *   the documentation and/or other materials provided with the

 *   distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED

 * OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "k5-int.h"

#include <gssapi/gssapi.h>

#include <gssapi/gssapi_ext.h>

#include <gssapi/gssapi_alloc.h>

struct test_context {

    int initiator;

    uint8_t hops;               /* hops remaining; 0 means established */

};

OM_uint32 KRB5_CALLCONV

gss_init_sec_context(OM_uint32 *minor_status,

                     gss_cred_id_t claimant_cred_handle,

                     gss_ctx_id_t *context_handle, gss_name_t target_name,

                     gss_OID mech_type, OM_uint32 req_flags,

                     OM_uint32 time_req,

                     gss_channel_bindings_t input_chan_bindings,

                     gss_buffer_t input_token, gss_OID *actual_mech,

                     gss_buffer_t output_token, OM_uint32 *ret_flags,

                     OM_uint32 *time_rec)

{

    struct test_context *ctx = (struct test_context *)*context_handle;

    OM_uint32 major;

    gss_buffer_desc tok;

    const char *envstr;

    uint8_t hops, mech_last_octet;

    envstr = getenv("GSS_INIT_BINDING");

    if (envstr != NULL) {

        assert(strlen(envstr) > 0);

        assert(input_chan_bindings != GSS_C_NO_CHANNEL_BINDINGS);

        assert(strlen(envstr) == input_chan_bindings->application_data.length);

        assert(strcmp((char *)input_chan_bindings->application_data.value,

                      envstr) == 0);

    }

    if (input_token == GSS_C_NO_BUFFER || input_token->length == 0) {

        envstr = getenv("HOPS");

        hops = (envstr != NULL) ? atoi(envstr) : 1;

        assert(hops > 0);

    } else if (input_token->length == 4 &&

               memcmp(input_token->value, "fail", 4) == 0) {

        *minor_status = 12345;

        return GSS_S_FAILURE;

    } else {

        hops = ((uint8_t *)input_token->value)[0];

    }

    mech_last_octet = ((uint8_t *)mech_type->elements)[mech_type->length - 1];

    envstr = getenv("INIT_FAIL");

    if (envstr != NULL && atoi(envstr) == mech_last_octet)

        return GSS_S_FAILURE;

    if (ctx == NULL) {

        ctx = malloc(sizeof(*ctx));

        assert(ctx != NULL);

        ctx->initiator = 1;

        ctx->hops = hops;

        *context_handle = (gss_ctx_id_t)ctx;

    } else if (ctx != NULL) {

        assert(ctx->initiator);

        ctx->hops--;

        assert(ctx->hops == hops);

    }

    if (ctx->hops > 0) {

        /* Generate a token containing the remaining hop count. */

        ctx->hops--;

        tok.value = &ctx->hops;

        tok.length = 1;

        major = gss_encapsulate_token(&tok, mech_type, output_token);

        assert(major == GSS_S_COMPLETE);

    }

    return (ctx->hops > 0) ? GSS_S_CONTINUE_NEEDED : GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_accept_sec_context(OM_uint32 *minor_status, gss_ctx_id_t *context_handle,

                       gss_cred_id_t verifier_cred_handle,

                       gss_buffer_t input_token,

                       gss_channel_bindings_t input_chan_bindings,

                       gss_name_t *src_name, gss_OID *mech_type,

                       gss_buffer_t output_token, OM_uint32 *ret_flags,

                       OM_uint32 *time_rec,

                       gss_cred_id_t *delegated_cred_handle)

{

    struct test_context *ctx = (struct test_context *)*context_handle;

    uint8_t hops, mech_last_octet;

    const char *envstr;

    envstr = getenv("GSS_ACCEPT_BINDING");

    if (envstr != NULL) {

        assert(strlen(envstr) > 0);

        assert(input_chan_bindings != GSS_C_NO_CHANNEL_BINDINGS);

        assert(strlen(envstr) == input_chan_bindings->application_data.length);

        assert(strcmp((char *)input_chan_bindings->application_data.value,

                      envstr) == 0);

    }

    /*

     * The unwrapped token sits at the end and is just one byte giving the

     * remaining number of hops.  The final octet of the mech encoding should

     * be just prior to it.

     */

    assert(input_token->length >= 2);

    hops = ((uint8_t *)input_token->value)[input_token->length - 1];

    mech_last_octet = ((uint8_t *)input_token->value)[input_token->length - 2];

    envstr = getenv("ACCEPT_FAIL");

    if (envstr != NULL && atoi(envstr) == mech_last_octet) {

        output_token->value = gssalloc_strdup("fail");

        assert(output_token->value != NULL);

        output_token->length = 4;

        return GSS_S_FAILURE;

    }

    if (*context_handle == GSS_C_NO_CONTEXT) {

        ctx = malloc(sizeof(*ctx));

        assert(ctx != NULL);

        ctx->initiator = 0;

        ctx->hops = hops;

        *context_handle = (gss_ctx_id_t)ctx;

    } else {

        assert(!ctx->initiator);

        ctx->hops--;

        assert(ctx->hops == hops);

    }

    if (ctx->hops > 0) {

        /* Generate a token containing the remaining hop count. */

        ctx->hops--;

        output_token->value = gssalloc_malloc(1);

        assert(output_token->value != NULL);

        memcpy(output_token->value, &ctx->hops, 1);

        output_token->length = 1;

    }

    return (ctx->hops > 0) ? GSS_S_CONTINUE_NEEDED : GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_delete_sec_context(OM_uint32 *minor_status, gss_ctx_id_t *context_handle,

                       gss_buffer_t output_token)

{

    free(*context_handle);

    *context_handle = GSS_C_NO_CONTEXT;

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_acquire_cred(OM_uint32 *minor_status, gss_name_t desired_name,

                 OM_uint32 time_req, gss_OID_set desired_mechs,

                 gss_cred_usage_t cred_usage,

                 gss_cred_id_t *output_cred_handle, gss_OID_set *actual_mechs,

                 OM_uint32 *time_rec)

{

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_acquire_cred_with_password(OM_uint32 *minor_status,

                               const gss_name_t desired_name,

                               const gss_buffer_t password, OM_uint32 time_req,

                               const gss_OID_set desired_mechs,

                               gss_cred_usage_t cred_usage,

                               gss_cred_id_t *output_cred_handle,

                               gss_OID_set *actual_mechs, OM_uint32 *time_rec)

{

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_release_cred(OM_uint32 *minor_status, gss_cred_id_t *cred_handle)

{

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_import_name(OM_uint32 *minor_status, gss_buffer_t input_name_buffer,

                gss_OID input_name_type, gss_name_t *output_name)

{

    static int dummy;

    /*

     * We don't need to remember anything about names, but we do need to

     * distinguish them from GSS_C_NO_NAME (to determine the direction of

     * gss_query_meta_data() and gss_exchange_meta_data()), so assign an

     * arbitrary data pointer.

     */

    *output_name = (gss_name_t)&dummy;

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_release_name(OM_uint32 *minor_status, gss_name_t *input_name)

{

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_display_status(OM_uint32 *minor_status, OM_uint32 status_value,

                   int status_type, gss_OID mech_type,

                   OM_uint32 *message_context, gss_buffer_t status_string)

{

    if (status_type == GSS_C_MECH_CODE && status_value == 12345) {

        status_string->value = gssalloc_strdup("failure from acceptor");

        assert(status_string->value != NULL);

        status_string->length = strlen(status_string->value);

        return GSS_S_COMPLETE;

    }

    return GSS_S_BAD_STATUS;

}

OM_uint32 KRB5_CALLCONV

gssspi_query_meta_data(OM_uint32 *minor_status, gss_const_OID mech_oid,

                       gss_cred_id_t cred_handle, gss_ctx_id_t *context_handle,

                       const gss_name_t targ_name, OM_uint32 req_flags,

                       gss_buffer_t meta_data)

{

    const char *envstr;

    uint8_t mech_last_octet;

    int initiator = (targ_name != GSS_C_NO_NAME);

    mech_last_octet = ((uint8_t *)mech_oid->elements)[mech_oid->length - 1];

    envstr = getenv(initiator ? "INIT_QUERY_FAIL" : "ACCEPT_QUERY_FAIL");

    if (envstr != NULL && atoi(envstr) == mech_last_octet)

        return GSS_S_FAILURE;

    envstr = getenv(initiator ? "INIT_QUERY_NONE" : "ACCEPT_QUERY_NONE");

    if (envstr != NULL && atoi(envstr) == mech_last_octet)

        return GSS_S_COMPLETE;

    meta_data->value = gssalloc_strdup("X");

    meta_data->length = 1;

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gssspi_exchange_meta_data(OM_uint32 *minor_status, gss_const_OID mech_oid,

                          gss_cred_id_t cred_handle,

                          gss_ctx_id_t *context_handle,

                          const gss_name_t targ_name, OM_uint32 req_flags,

                          gss_const_buffer_t meta_data)

{

    const char *envstr;

    uint8_t mech_last_octet;

    int initiator = (targ_name != GSS_C_NO_NAME);

    mech_last_octet = ((uint8_t *)mech_oid->elements)[mech_oid->length - 1];

    envstr = getenv(initiator ? "INIT_EXCHANGE_FAIL" : "ACCEPT_EXCHANGE_FAIL");

    if (envstr != NULL && atoi(envstr) == mech_last_octet)

        return GSS_S_FAILURE;

    assert(meta_data->length == 1 && memcmp(meta_data->value, "X", 1) == 0);

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gssspi_query_mechanism_info(OM_uint32 *minor_status, gss_const_OID mech_oid,

                            unsigned char auth_scheme[16])

{

    /* Copy the mech OID encoding and right-pad it with zeros. */

    memset(auth_scheme, 0, 16);

    assert(mech_oid->length <= 16);

    memcpy(auth_scheme, mech_oid->elements, mech_oid->length);

    return GSS_S_COMPLETE;

}

OM_uint32 KRB5_CALLCONV

gss_inquire_sec_context_by_oid(OM_uint32 *minor_status,

                               const gss_ctx_id_t context_handle,

                               const gss_OID desired_object,

                               gss_buffer_set_t *data_set)

{

    struct test_context *ctx = (struct test_context *)context_handle;

    OM_uint32 major;

    uint8_t keybytes[32] = { 0 };

    uint8_t typebytes[4];

    gss_buffer_desc key, type;

    const char *envstr;

    int ask_verify;

    if (gss_oid_equal(desired_object, GSS_C_INQ_NEGOEX_KEY))

        ask_verify = 0;

    else if (gss_oid_equal(desired_object, GSS_C_INQ_NEGOEX_VERIFY_KEY))

        ask_verify = 1;

    else

        return GSS_S_UNAVAILABLE;

    /*

     * By default, make a key available only if the context is established.

     * This can be overridden to "always", "init-always", "accept-always",

     * or "never".

     */

    envstr = getenv("KEY");

    if (envstr != NULL && strcmp(envstr, "never") == 0) {

        return GSS_S_UNAVAILABLE;

    } else if (ctx->hops > 0) {

        if (envstr == NULL)

            return GSS_S_UNAVAILABLE;

        else if (strcmp(envstr, "init-always") == 0 && !ctx->initiator)

            return GSS_S_UNAVAILABLE;

        else if (strcmp(envstr, "accept-always") == 0 && ctx->initiator)

            return GSS_S_UNAVAILABLE;

    }

    /* Perturb the key so that each side's verifier key is equal to the other's

     * checksum key. */

    keybytes[0] = ask_verify ^ ctx->initiator;

    /* Supply an all-zeros aes256-sha1 negoex key. */

    if (gss_oid_equal(desired_object, GSS_C_INQ_NEGOEX_KEY) ||

        gss_oid_equal(desired_object, GSS_C_INQ_NEGOEX_VERIFY_KEY)) {

        store_32_le(ENCTYPE_AES256_CTS_HMAC_SHA1_96, typebytes);

        key.value = keybytes;

        key.length = sizeof(keybytes);

        type.value = typebytes;

        type.length = sizeof(typebytes);

        major = gss_add_buffer_set_member(minor_status, &key, data_set);

        if (major != GSS_S_COMPLETE)

            return major;

        return gss_add_buffer_set_member(minor_status, &type, data_set);

    }

    return GSS_S_UNAVAILABLE;

}