/*

 * 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];

#else

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

#endif

typedef struct {

    TCHAR PackageName[20];

    CredHandle* phCred;

    struct _SecHandle hCtxt;

    DWORD cbMaxMessage;

    SecPkgContext_Sizes SecPkgContextSizes;

} Context;

#ifdef __cplusplus

extern "C" {

#endif /* __cplusplus */

__declspec(dllexport) OM_uint32 gss_release_name

                                (OM_uint32 *minor_status,

                                gss_name_t *name) {

}

__declspec(dllexport) OM_uint32 gss_import_name

                                (OM_uint32 *minor_status,

                                gss_buffer_t input_name_buffer,

                                gss_OID input_name_type,

                                gss_name_t *output_name) {

    SecPkgCredentials_Names* names = new SecPkgCredentials_Names();

    int len = (int)input_name_buffer->length;

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

    names->sUserName[len] = 0;

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

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

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

            }

        }

    }

    *output_name = (gss_name_t) names;

    return GSS_S_COMPLETE;

}

__declspec(dllexport) OM_uint32 gss_compare_name

                                (OM_uint32 *minor_status,

                                gss_name_t name1,

                                gss_name_t name2,

                                int *name_equal) {

}

__declspec(dllexport) OM_uint32 gss_canonicalize_name

                                (OM_uint32 *minor_status,

                                gss_name_t input_name,

                                gss_OID mech_type,

                                gss_name_t *output_name) {

}

__declspec(dllexport) OM_uint32 gss_export_name

                                (OM_uint32 *minor_status,

                                gss_name_t input_name,

                                gss_buffer_t exported_name) {

    return GSS_S_FAILURE;

}

__declspec(dllexport) OM_uint32 gss_display_name

                                (OM_uint32 *minor_status,

                                gss_name_t input_name,

                                gss_buffer_t output_name_buffer,

                                gss_OID *output_name_type) {

    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;

    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;

}

long TimeStampToLong(TimeStamp *time) {

    ULARGE_INTEGER *a, *b;

    FILETIME fnow;

    GetSystemTimeAsFileTime(&fnow);

    a = (ULARGE_INTEGER*)time;

    b = (ULARGE_INTEGER*)&fnow;

    return (long)((a->QuadPart - b->QuadPart) / 10000000);

}

__declspec(dllexport) OM_uint32 gss_acquire_cred

                                (OM_uint32 *minor_status,

                                gss_name_t desired_name,

                                OM_uint32 time_req,

                                gss_OID_set desired_mech,

                                gss_cred_usage_t cred_usage,

                                gss_cred_id_t *output_cred_handle,

                                gss_OID_set *actual_mechs,

                                OM_uint32 *time_rec) {

    if (desired_name != NULL) {

        return GSS_S_FAILURE; // Only support default cred

    }

    SECURITY_STATUS ss;

    CredHandle* cred = new CredHandle();

    TimeStamp ts;

	cred_usage = 0;

    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,

            &ts

            );

    actual_mechs = &desired_mech;

    *output_cred_handle = (void*)cred;

    if (time_rec != NULL) {

        *time_rec = TimeStampToLong(&ts);

    }

    return GSS_S_COMPLETE;

}

__declspec(dllexport) OM_uint32 gss_release_cred

                                (OM_uint32 *minor_status,

                                gss_cred_id_t *cred_handle) {

}

__declspec(dllexport) OM_uint32 gss_inquire_cred

                                (OM_uint32 *minor_status,

                                gss_cred_id_t cred_handle,

                                gss_name_t *name,

                                OM_uint32 *lifetime,

                                gss_cred_usage_t *cred_usage,

                                gss_OID_set *mechanisms) {

    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;

}

__declspec(dllexport) OM_uint32 gss_import_sec_context

                                (OM_uint32 *minor_status,

                                gss_buffer_t interprocess_token,

                                gss_ctx_id_t *context_handle) {

    return GSS_S_FAILURE;

}

void FillContextAfterEstablished(Context *pc) {

    QueryContextAttributes(&pc->hCtxt, SECPKG_ATTR_SIZES,

                &pc->SecPkgContextSizes);

}

Context* NewContext(TCHAR* PackageName) {

    SECURITY_STATUS ss;

    PSecPkgInfo pkgInfo;

    Context* out = (Context*)malloc(sizeof(Context));

    ss = QuerySecurityPackageInfo(

            PackageName,

            &pkgInfo);

    if (!SEC_SUCCESS(ss)) {

        return NULL;

    }

    out->phCred = NULL;

    out->cbMaxMessage = pkgInfo->cbMaxToken;

    wcscpy(out->PackageName, PackageName);

    FreeContextBuffer(pkgInfo);

    return out;

}

int flagSspi2Gss(int fin) {

	int fout = 0;

	if (fin & ISC_REQ_MUTUAL_AUTH) fout |= GSS_C_MUTUAL_FLAG;

	if (fin & ISC_REQ_CONFIDENTIALITY) fout |= GSS_C_CONF_FLAG;

	if (fin & ISC_REQ_DELEGATE) fout |= GSS_C_DELEG_FLAG;

	if (fin & ISC_REQ_INTEGRITY) fout |= GSS_C_INTEG_FLAG;

	if (fin & ISC_REQ_REPLAY_DETECT) fout |= GSS_C_REPLAY_FLAG;

	if (fin & ISC_REQ_SEQUENCE_DETECT) fout |= GSS_C_SEQUENCE_FLAG;

	return fout;

}

int flagGss2Sspi(int fin) {

	int fout = 0;

	if (fin & GSS_C_MUTUAL_FLAG) fout |= ISC_RET_MUTUAL_AUTH;

	if (fin & GSS_C_CONF_FLAG) fout |= ISC_RET_CONFIDENTIALITY;

	if (fin & GSS_C_DELEG_FLAG) fout |= ISC_RET_DELEGATE;

	if (fin & GSS_C_INTEG_FLAG) fout |= ISC_RET_INTEGRITY;

	if (fin & GSS_C_REPLAY_FLAG) fout |= ISC_RET_REPLAY_DETECT;

	if (fin & GSS_C_SEQUENCE_FLAG) fout |= ISC_RET_SEQUENCE_DETECT;

	return fout;

}

__declspec(dllexport) OM_uint32 gss_init_sec_context

                                (OM_uint32 *minor_status,

                                gss_cred_id_t initiator_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_type,

                                gss_buffer_t output_token,

                                OM_uint32 *ret_flags,

                                OM_uint32 *time_rec) {

    SECURITY_STATUS ss;

    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);

    outName[tn.length] = 0;

    BOOL pfDone;

	if (!SEC_SUCCESS(ss)) {

		return GSS_S_FAILURE;

	}

    *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;

    }

}

__declspec(dllexport) OM_uint32 gss_accept_sec_context

                                (OM_uint32 *minor_status,

                                gss_ctx_id_t *context_handle,

                                gss_cred_id_t acceptor_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) {

    return GSS_S_FAILURE;

}

__declspec(dllexport) OM_uint32 gss_inquire_context

                                (OM_uint32 *minor_status,

                                gss_ctx_id_t context_handle,

                                gss_name_t *src_name,

                                gss_name_t *targ_name,

                                OM_uint32 *lifetime_rec,

                                gss_OID *mech_type,

                                OM_uint32 *ctx_flags,

                                int *locally_initiated,

                                int *open) {

    Context* pc = (Context*) context_handle;

    return GSS_S_FAILURE;

}

__declspec(dllexport) OM_uint32 gss_delete_sec_context

                                (OM_uint32 *minor_status,

                                gss_ctx_id_t *context_handle,