/*

 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#define UNICODE

#define _UNICODE

#include <windows.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define GSS_DLL_FILE

#include "gssapi.h"

#define SECURITY_WIN32

#include <sspi.h>

#pragma comment(lib, "secur32.lib")

#ifdef DEBUG

TCHAR _bb[256];

#define SEC_SUCCESS(Status) \

        ((Status) >= 0 ? TRUE: \

        (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, \

            0, ss, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), _bb, 256, 0), \

        printf("SECURITY_STATUS: (%lx) %ls\n", ss, _bb), \

        FALSE))

#define PP(fmt, ...) \

        fprintf(stdout, "SSPI (%ld): ", __LINE__); \

        fprintf(stdout, fmt, ##__VA_ARGS__); \

        fflush(stdout)

#else

#define SEC_SUCCESS(Status) ((Status) >= 0)

#define PP(dmt, ...)

#endif

char KRB5_OID[9] = {

        (char)0x2a, (char)0x86, (char)0x48, (char)0x86, (char)0xf7, (char)0x12,

        (char)0x01, (char)0x02, (char)0x02};

char SPNEGO_OID[6] = {

        (char)0x2b, (char)0x06, (char)0x01, (char)0x05, (char)0x05, (char)0x02};

char USER_NAME_OID[10] = {

        (char)0x2a, (char)0x86, (char)0x48, (char)0x86, (char)0xf7, (char)0x12,

        (char)0x01, (char)0x02, (char)0x01, (char)0x01};

char HOST_SERVICE_NAME_OID[10] = {

        (char)0x2a, (char)0x86, (char)0x48, (char)0x86, (char)0xf7, (char)0x12,

        (char)0x01, (char)0x02, (char)0x01, (char)0x04};

// gss_name_t is SecPkgCredentials_Names*

// gss_cred_id_t is CredHandle*

// gss_ctx_id_t is Context*

typedef struct {

    TCHAR PackageName[20];

    CredHandle* phCred;

    struct _SecHandle hCtxt;

    DWORD cbMaxMessage;

    SecPkgContext_Sizes SecPkgContextSizes;

} Context;

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */

    if (name != NULL) {

        SecPkgCredentials_Names* names = (SecPkgCredentials_Names*)name;

        if (names->sUserName != NULL) {

            delete[] names->sUserName;

        }

        delete names;

        *name = GSS_C_NO_NAME;

    }

    return GSS_S_COMPLETE;

}

    if (input_name_buffer == NULL || input_name_buffer->value == NULL

            || input_name_buffer->length == 0) {

        return GSS_S_BAD_NAME;

    }

    SecPkgCredentials_Names* names = new SecPkgCredentials_Names();

    if (names == NULL) {

        goto err;

    }

    int len = (int)input_name_buffer->length;

    names->sUserName = new SEC_WCHAR[len + 1];

    if (names->sUserName == NULL) {

        goto err;

    }

    if (MultiByteToWideChar(CP_ACP, 0, (LPSTR)input_name_buffer->value, len,

            names->sUserName, len) == 0) {

        goto err;

    }

    names->sUserName[len] = 0;

    if (input_name_type != NULL && input_name_type->length == 10

            && !memcmp(input_name_type->elements, HOST_SERVICE_NAME_OID, 10)) {

        for (int i = 0; i < len; i++) {

            if (names->sUserName[i] == '@') {

                names->sUserName[i] = '/';

                break;

            }

        }

    }

    *output_name = (gss_name_t) names;

    return GSS_S_COMPLETE;

err:

    if (names != NULL && names->sUserName != NULL) {

        delete[] names->sUserName;

    }

    if (names != NULL) {

        delete names;

    }

    return GSS_S_FAILURE;

}

    if (name1 == NULL || name2 == NULL) {

        *name_equal = 0;

        return GSS_S_BAD_NAME;

    }

    SecPkgCredentials_Names* names1 = (SecPkgCredentials_Names*)name1;

    SecPkgCredentials_Names* names2 = (SecPkgCredentials_Names*)name2;

    if (lstrcmp(names1->sUserName, names2->sUserName)) {

        *name_equal = 0;

    } else {

        *name_equal = 1;

    }

    return GSS_S_COMPLETE;

}

    SecPkgCredentials_Names* names1 = (SecPkgCredentials_Names*)input_name;

    SecPkgCredentials_Names* names2 = new SecPkgCredentials_Names();

    names2->sUserName = new SEC_WCHAR[lstrlen(names1->sUserName) + 1];

    lstrcpy(names2->sUserName, names1->sUserName);

    *output_name = (gss_name_t)names2;

    return GSS_S_COMPLETE;

}

    SecPkgCredentials_Names* names = (SecPkgCredentials_Names*)input_name;

    int len = (int)wcslen(names->sUserName);

    char* buffer = new char[len+1];

    WideCharToMultiByte(CP_ACP, 0, names->sUserName, len, buffer, len, NULL, NULL);

    buffer[len] = 0;

    exported_name->length = len+1;

    exported_name->value = buffer;

    return GSS_S_FAILURE;

}

    SecPkgCredentials_Names* names = (SecPkgCredentials_Names*)input_name;

    int len = (int)wcslen(names->sUserName);

    char* buffer = new char[len+1];

    WideCharToMultiByte(CP_ACP, 0, names->sUserName, len, buffer, len, NULL, NULL);

    buffer[len] = 0;

    output_name_buffer->length = len+1;

    output_name_buffer->value = buffer;

    PP("Name found: %ls\n", names->sUserName);

    PP("%d [%s]", len, buffer);

    if (output_name_type != NULL) {

        gss_OID_desc* oid = new gss_OID_desc();

        oid->length = (OM_uint32)strlen(USER_NAME_OID);

        oid->elements = strdup(USER_NAME_OID);

        *output_name_type = oid;

    }

    return GSS_S_COMPLETE;

}

    if (desired_name != NULL) {

        return GSS_S_FAILURE; // Only support default cred

    }

    SECURITY_STATUS ss;

    CredHandle* cred = new CredHandle();

    TimeStamp ts;

	cred_usage = 0;

    PP("AcquireCredentialsHandle with %d\n", cred_usage);

    ss = AcquireCredentialsHandle(

            NULL,

            L"Kerberos",

            cred_usage == 0 ? SECPKG_CRED_BOTH :

                (cred_usage == 1 ? SECPKG_CRED_OUTBOUND : SECPKG_CRED_INBOUND),

            NULL,

            NULL,

            NULL,

            NULL,

            cred,

    actual_mechs = &desired_mech;

    *output_cred_handle = (void*)cred;

    if (time_rec != NULL) {

        *time_rec = TimeStampToLong(&ts);

    }

    return GSS_S_COMPLETE;

}

    if (cred_handle && *cred_handle) {

        FreeCredentialsHandle((CredHandle*)*cred_handle);

        *cred_handle = GSS_C_NO_CREDENTIAL;

    }

    return GSS_S_COMPLETE;

}

    CredHandle* cred = (CredHandle*)cred_handle;

    SECURITY_STATUS ss;

    if (name) {

        SecPkgCredentials_Names* names = new SecPkgCredentials_Names();

        ss = QueryCredentialsAttributes(cred, SECPKG_CRED_ATTR_NAMES, names);

        *name = (gss_name_t) names;

    }

    // Others inquiries not supported yet

    return GSS_S_COMPLETE;

}

    return GSS_S_FAILURE;

}

    SECURITY_STATUS ss;

    TimeStamp Lifetime;

    SecBufferDesc InBuffDesc;

    SecBuffer InSecBuff;

    SecBufferDesc OutBuffDesc;

    SecBuffer OutSecBuff;

    Context* pc;

    if (input_token->length == 0) {

        pc = NewContext(L"Kerberos");

        pc->phCred = (CredHandle*)initiator_cred_handle;

        *context_handle = (gss_ctx_id_t) pc;

    } else {

        pc = (Context*)*context_handle;

    }

    output_token->length = pc->cbMaxMessage;

    output_token->value = new char[pc->cbMaxMessage];

    DWORD outFlag;    

    TCHAR outName[100];

    OM_uint32 minor;

    gss_buffer_desc tn;

    gss_display_name(&minor, target_name, &tn, NULL);

    MultiByteToWideChar(CP_ACP, 0, (LPCCH)tn.value, (int)tn.length,

            outName, (int)tn.length);

    outName[tn.length] = 0;

    BOOL pfDone;

    int flag = flagGss2Sspi(req_flags);

    OutBuffDesc.ulVersion = SECBUFFER_VERSION;

    OutBuffDesc.cBuffers = 1;

    OutBuffDesc.pBuffers = &OutSecBuff;

    OutSecBuff.cbBuffer = (ULONG)output_token->length;

    OutSecBuff.BufferType = SECBUFFER_TOKEN;

    OutSecBuff.pvBuffer = output_token->value;

    if (input_token->value) {

        InBuffDesc.ulVersion = SECBUFFER_VERSION;

        InBuffDesc.cBuffers = 1;

        InBuffDesc.pBuffers = &InSecBuff;

        InSecBuff.BufferType = SECBUFFER_TOKEN;

        InSecBuff.cbBuffer = (ULONG)input_token->length;

        InSecBuff.pvBuffer = input_token->value;

    } else {

        if (!pc->phCred) {

            PP("No credentials provided, acquire automatically");

            ss = AcquireCredentialsHandle(

                    NULL,

                    pc->PackageName,

                    SECPKG_CRED_OUTBOUND,

                    NULL,

                    NULL,

                    NULL,

                    NULL,

                    pc->phCred,

                    &Lifetime);

            PP("end");

            if (!(SEC_SUCCESS(ss))) {

                PP("Failed");

                return GSS_S_FAILURE;

            }

        } else {

            PP("Credentials OK");

        }

    }

    ss = InitializeSecurityContext(

            pc->phCred,

            input_token->value ? &pc->hCtxt : NULL,

            outName,

            flag,

            0,

            SECURITY_NATIVE_DREP,

            input_token->value ? &InBuffDesc : NULL,

            0,

            &pc->hCtxt,

            &OutBuffDesc,

            &outFlag,

            &Lifetime);

	if (!SEC_SUCCESS(ss)) {

		return GSS_S_FAILURE;

	}

    if ((SEC_I_COMPLETE_NEEDED == ss)

            || (SEC_I_COMPLETE_AND_CONTINUE == ss)) {

        ss = CompleteAuthToken(&pc->hCtxt, &OutBuffDesc);

        if (!SEC_SUCCESS(ss)) {

            return GSS_S_FAILURE;

        }

    }

    output_token->length =  OutSecBuff.cbBuffer;

    pfDone = !((SEC_I_CONTINUE_NEEDED == ss) ||

                (SEC_I_COMPLETE_AND_CONTINUE == ss));

    if (ss == SEC_E_OK) FillContextAfterEstablished(pc);

	outFlag = flagSspi2Gss(outFlag);

    *ret_flags = (OM_uint32)outFlag;

    if (ss == SEC_I_CONTINUE_NEEDED) {

        return GSS_S_CONTINUE_NEEDED;

    } else {

        *ret_flags |= GSS_C_PROT_READY_FLAG;

        return GSS_S_COMPLETE;

    }

}