negotiate.c File Reference

#include "precomp.h"
#include <wine/debug.h>

Include dependency graph for negotiate.c:

Go to the source code of this file.

Macros
#define	NEGO_MAX_TOKEN   12000
#define	CAPS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (secur32)
static SECURITY_STATUS SEC_ENTRY	nego_QueryCredentialsAttributesA (PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer)
static SECURITY_STATUS SEC_ENTRY	nego_QueryCredentialsAttributesW (PCredHandle phCredential, ULONG ulAttribute, PVOID pBuffer)
static SECURITY_STATUS SEC_ENTRY	nego_AcquireCredentialsHandleW (SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse, PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
static SECURITY_STATUS SEC_ENTRY	nego_AcquireCredentialsHandleA (SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse, PLUID pLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, PVOID pGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
static SECURITY_STATUS SEC_ENTRY	nego_InitializeSecurityContextW (PCredHandle phCredential, PCtxtHandle phContext, SEC_WCHAR *pszTargetName, ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput, ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
static SECURITY_STATUS SEC_ENTRY	nego_InitializeSecurityContextA (PCredHandle phCredential, PCtxtHandle phContext, SEC_CHAR *pszTargetName, ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput, ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
static SECURITY_STATUS SEC_ENTRY	nego_AcceptSecurityContext (PCredHandle phCredential, PCtxtHandle phContext, PSecBufferDesc pInput, ULONG fContextReq, ULONG TargetDataRep, PCtxtHandle phNewContext, PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
static SECURITY_STATUS SEC_ENTRY	nego_CompleteAuthToken (PCtxtHandle phContext, PSecBufferDesc pToken)
static SECURITY_STATUS SEC_ENTRY	nego_DeleteSecurityContext (PCtxtHandle phContext)
static SECURITY_STATUS SEC_ENTRY	nego_ApplyControlToken (PCtxtHandle phContext, PSecBufferDesc pInput)
static SECURITY_STATUS SEC_ENTRY	nego_QueryContextAttributesW (PCtxtHandle phContext, ULONG ulAttribute, void *pBuffer)
static SECURITY_STATUS SEC_ENTRY	nego_QueryContextAttributesA (PCtxtHandle phContext, ULONG ulAttribute, void *pBuffer)
static SECURITY_STATUS SEC_ENTRY	nego_ImpersonateSecurityContext (PCtxtHandle phContext)
static SECURITY_STATUS SEC_ENTRY	nego_RevertSecurityContext (PCtxtHandle phContext)
static SECURITY_STATUS SEC_ENTRY	nego_MakeSignature (PCtxtHandle phContext, ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo)
static SECURITY_STATUS SEC_ENTRY	nego_VerifySignature (PCtxtHandle phContext, PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
static SECURITY_STATUS SEC_ENTRY	nego_FreeCredentialsHandle (PCredHandle phCredential)
static SECURITY_STATUS SEC_ENTRY	nego_EncryptMessage (PCtxtHandle phContext, ULONG fQOP, PSecBufferDesc pMessage, ULONG MessageSeqNo)
static SECURITY_STATUS SEC_ENTRY	nego_DecryptMessage (PCtxtHandle phContext, PSecBufferDesc pMessage, ULONG MessageSeqNo, PULONG pfQOP)
void	SECUR32_initNegotiateSP (void)

Variables
static const SecurityFunctionTableA	negoTableA
static const SecurityFunctionTableW	negoTableW
static WCHAR	nego_name_W [] = {'N','e','g','o','t','i','a','t','e',0}
static char	nego_name_A [] = "Negotiate"
static WCHAR	negotiate_comment_W []
static CHAR	negotiate_comment_A [] = "Microsoft Package Negotiator"

Macro Definition Documentation

CAPS

#define CAPS

Value:

( \
    SECPKG_FLAG_INTEGRITY  | \
    SECPKG_FLAG_PRIVACY    | \
    SECPKG_FLAG_CONNECTION | \
    SECPKG_FLAG_MULTI_REQUIRED | \
    SECPKG_FLAG_EXTENDED_ERROR | \
    SECPKG_FLAG_IMPERSONATION  | \
    SECPKG_FLAG_ACCEPT_WIN32_NAME | \
    SECPKG_FLAG_NEGOTIABLE        | \
    SECPKG_FLAG_GSS_COMPATIBLE    | \
    SECPKG_FLAG_LOGON             | \
    SECPKG_FLAG_RESTRICTED_TOKENS )

Definition at line 503 of file negotiate.c.

NEGO_MAX_TOKEN

#define NEGO_MAX_TOKEN   12000

Definition at line 493 of file negotiate.c.

Function Documentation

nego_AcceptSecurityContext()

static SECURITY_STATUS SEC_ENTRY nego_AcceptSecurityContext ( PCredHandle  phCredential, PCtxtHandle  phContext, PSecBufferDesc  pInput, ULONG  fContextReq, ULONG  TargetDataRep, PCtxtHandle  phNewContext, PSecBufferDesc  pOutput, ULONG *  pfContextAttr, PTimeStamp  ptsExpiry  )

static

Definition at line 213 of file negotiate.c.

{
    TRACE("%p, %p, %p, 0x%08x, %u, %p, %p, %p, %p\n", phCredential, phContext,
          pInput, fContextReq, TargetDataRep, phNewContext, pOutput, pfContextAttr,
          ptsExpiry);

    return ntlm_AcceptSecurityContext( phCredential, phContext, pInput,
                                       fContextReq, TargetDataRep, phNewContext,
                                       pOutput, pfContextAttr, ptsExpiry );
}

nego_AcquireCredentialsHandleA()

static SECURITY_STATUS SEC_ENTRY nego_AcquireCredentialsHandleA ( SEC_CHAR *  pszPrincipal, SEC_CHAR *  pszPackage, ULONG  fCredentialUse, PLUID  pLogonID, PVOID  pAuthData, SEC_GET_KEY_FN  pGetKeyFn, PVOID  pGetKeyArgument, PCredHandle  phCredential, PTimeStamp  ptsExpiry  )

static

Definition at line 78 of file negotiate.c.

{
    SECURITY_STATUS ret = SEC_E_INSUFFICIENT_MEMORY;
    SEC_WCHAR *user = NULL, *domain = NULL, *passwd = NULL, *package = NULL;
    SEC_WINNT_AUTH_IDENTITY_W *identityW = NULL;

    TRACE("%s, %s, 0x%08x, %p, %p, %p, %p, %p, %p\n",
          debugstr_a(pszPrincipal), debugstr_a(pszPackage), fCredentialUse,
          pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry);

    if (pszPackage)
    {
        int package_len = MultiByteToWideChar( CP_ACP, 0, pszPackage, -1, NULL, 0 );
        package = HeapAlloc( GetProcessHeap(), 0, package_len * sizeof(SEC_WCHAR) );
        if (!package) return SEC_E_INSUFFICIENT_MEMORY;
        MultiByteToWideChar( CP_ACP, 0, pszPackage, -1, package, package_len );
    }
    if (pAuthData)
    {
        SEC_WINNT_AUTH_IDENTITY_A *identity = pAuthData;
        int user_len, domain_len, passwd_len;

        if (identity->Flags == SEC_WINNT_AUTH_IDENTITY_ANSI)
        {
            identityW = HeapAlloc( GetProcessHeap(), 0, sizeof(*identityW) );
            if (!identityW) goto done;

            if (!identity->UserLength) user_len = 0;
            else
            {
                user_len = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)identity->User,
                                                identity->UserLength, NULL, 0 );
                user = HeapAlloc( GetProcessHeap(), 0, user_len * sizeof(SEC_WCHAR) );
                if (!user) goto done;
                MultiByteToWideChar( CP_ACP, 0, (LPCSTR)identity->User, identity->UserLength,
                                     user, user_len );
            }
            if (!identity->DomainLength) domain_len = 0;
            else
            {
                domain_len = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)identity->Domain,
                                                  identity->DomainLength, NULL, 0 );
                domain = HeapAlloc( GetProcessHeap(), 0, domain_len * sizeof(SEC_WCHAR) );
                if (!domain) goto done;
                MultiByteToWideChar( CP_ACP, 0, (LPCSTR)identity->Domain, identity->DomainLength,
                                     domain, domain_len );
            }
            if (!identity->PasswordLength) passwd_len = 0;
            else
            {
                passwd_len = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)identity->Password,
                                                  identity->PasswordLength, NULL, 0 );
                passwd = HeapAlloc( GetProcessHeap(), 0, passwd_len * sizeof(SEC_WCHAR) );
                if (!passwd) goto done;
                MultiByteToWideChar( CP_ACP, 0, (LPCSTR)identity->Password, identity->PasswordLength,
                                     passwd, passwd_len );
            }
            identityW->Flags          = SEC_WINNT_AUTH_IDENTITY_UNICODE;
            identityW->User           = user;
            identityW->UserLength     = user_len;
            identityW->Domain         = domain;
            identityW->DomainLength   = domain_len;
            identityW->Password       = passwd;
            identityW->PasswordLength = passwd_len;
        }
        else identityW = (SEC_WINNT_AUTH_IDENTITY_W *)identity;
    }
    ret = nego_AcquireCredentialsHandleW( NULL, package, fCredentialUse, pLogonID, identityW,
                                          pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry );
done:
    HeapFree( GetProcessHeap(), 0, package );
    HeapFree( GetProcessHeap(), 0, user );
    HeapFree( GetProcessHeap(), 0, domain );
    HeapFree( GetProcessHeap(), 0, passwd );
    HeapFree( GetProcessHeap(), 0, identityW );
    return ret;
}

nego_AcquireCredentialsHandleW()

static SECURITY_STATUS SEC_ENTRY nego_AcquireCredentialsHandleW ( SEC_WCHAR *  pszPrincipal, SEC_WCHAR *  pszPackage, ULONG  fCredentialUse, PLUID  pLogonID, PVOID  pAuthData, SEC_GET_KEY_FN  pGetKeyFn, PVOID  pGetKeyArgument, PCredHandle  phCredential, PTimeStamp  ptsExpiry  )

static

Definition at line 51 of file negotiate.c.

{
    static SEC_WCHAR ntlmW[] = {'N','T','L','M',0};
    SECURITY_STATUS ret;

    TRACE("%s, %s, 0x%08x, %p, %p, %p, %p, %p, %p\n",
          debugstr_w(pszPrincipal), debugstr_w(pszPackage), fCredentialUse,
          pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument, phCredential, ptsExpiry);

    FIXME("forwarding to NTLM\n");
    ret = ntlm_AcquireCredentialsHandleW( pszPrincipal, ntlmW, fCredentialUse,
                                          pLogonID, pAuthData, pGetKeyFn, pGetKeyArgument,
                                          phCredential, ptsExpiry );
    if (ret == SEC_E_OK)
    {
        NtlmCredentials *cred = (NtlmCredentials *)phCredential->dwLower;
        cred->no_cached_credentials = (pAuthData == NULL);
    }
    return ret;
}

Referenced by nego_AcquireCredentialsHandleA().

nego_ApplyControlToken()

static SECURITY_STATUS SEC_ENTRY nego_ApplyControlToken ( PCtxtHandle  phContext, PSecBufferDesc  pInput  )

static

Definition at line 260 of file negotiate.c.

{
    SECURITY_STATUS ret;

    TRACE("%p %p\n", phContext, pInput);
    if (phContext)
    {
        ret = SEC_E_UNSUPPORTED_FUNCTION;
    }
    else
    {
        ret = SEC_E_INVALID_HANDLE;
    }
    return ret;
}

nego_CompleteAuthToken()

static SECURITY_STATUS SEC_ENTRY nego_CompleteAuthToken ( PCtxtHandle  phContext, PSecBufferDesc  pToken  )

static

Definition at line 230 of file negotiate.c.

{
    SECURITY_STATUS ret;

    TRACE("%p %p\n", phContext, pToken);
    if (phContext)
    {
        ret = SEC_E_UNSUPPORTED_FUNCTION;
    }
    else
    {
        ret = SEC_E_INVALID_HANDLE;
    }
    return ret;
}

nego_DecryptMessage()

static SECURITY_STATUS SEC_ENTRY nego_DecryptMessage ( PCtxtHandle  phContext, PSecBufferDesc  pMessage, ULONG  MessageSeqNo, PULONG  pfQOP  )

static

Definition at line 423 of file negotiate.c.

{
    TRACE("%p, %p, %u, %p\n", phContext, pMessage, MessageSeqNo, pfQOP);

    return ntlm_DecryptMessage( phContext, pMessage, MessageSeqNo, pfQOP );
}

nego_DeleteSecurityContext()

static SECURITY_STATUS SEC_ENTRY nego_DeleteSecurityContext ( PCtxtHandle  phContext )

static

Definition at line 250 of file negotiate.c.

{
    TRACE("%p\n", phContext);

    return ntlm_DeleteSecurityContext( phContext );
}

nego_EncryptMessage()

static SECURITY_STATUS SEC_ENTRY nego_EncryptMessage ( PCtxtHandle  phContext, ULONG  fQOP, PSecBufferDesc  pMessage, ULONG  MessageSeqNo  )

static

Definition at line 412 of file negotiate.c.

{
    TRACE("%p, 0x%08x, %p, %u\n", phContext, fQOP, pMessage, MessageSeqNo);

    return ntlm_EncryptMessage( phContext, fQOP, pMessage, MessageSeqNo );
}

nego_FreeCredentialsHandle()

static SECURITY_STATUS SEC_ENTRY nego_FreeCredentialsHandle ( PCredHandle  phCredential )

static

Definition at line 402 of file negotiate.c.

{
    TRACE("%p\n", phCredential);

    return ntlm_FreeCredentialsHandle( phCredential );
}

nego_ImpersonateSecurityContext()

static SECURITY_STATUS SEC_ENTRY nego_ImpersonateSecurityContext ( PCtxtHandle  phContext )

static

Definition at line 342 of file negotiate.c.

{
    SECURITY_STATUS ret;

    TRACE("%p\n", phContext);
    if (phContext)
    {
        ret = SEC_E_UNSUPPORTED_FUNCTION;
    }
    else
    {
        ret = SEC_E_INVALID_HANDLE;
    }
    return ret;
}

nego_InitializeSecurityContextA()

static SECURITY_STATUS SEC_ENTRY nego_InitializeSecurityContextA ( PCredHandle  phCredential, PCtxtHandle  phContext, SEC_CHAR *  pszTargetName, ULONG  fContextReq, ULONG  Reserved1, ULONG  TargetDataRep, PSecBufferDesc  pInput, ULONG  Reserved2, PCtxtHandle  phNewContext, PSecBufferDesc  pOutput, ULONG *  pfContextAttr, PTimeStamp  ptsExpiry  )

static

Definition at line 182 of file negotiate.c.

{
    SECURITY_STATUS ret;
    SEC_WCHAR *target = NULL;

    TRACE("%p, %p, %s, 0x%08x, %u, %u, %p, %u, %p, %p, %p, %p\n",
          phCredential, phContext, debugstr_a(pszTargetName), fContextReq,
          Reserved1, TargetDataRep, pInput, Reserved1, phNewContext, pOutput,
          pfContextAttr, ptsExpiry);

    if (pszTargetName)
    {
        int target_len = MultiByteToWideChar( CP_ACP, 0, pszTargetName, -1, NULL, 0 );
        target = HeapAlloc(GetProcessHeap(), 0, target_len * sizeof(SEC_WCHAR) );
        if (!target) return SEC_E_INSUFFICIENT_MEMORY;
        MultiByteToWideChar( CP_ACP, 0, pszTargetName, -1, target, target_len );
    }
    ret = nego_InitializeSecurityContextW( phCredential, phContext, target, fContextReq,
                                           Reserved1, TargetDataRep, pInput, Reserved2,
                                           phNewContext, pOutput, pfContextAttr, ptsExpiry );
    HeapFree( GetProcessHeap(), 0, target );
    return ret;
}

nego_InitializeSecurityContextW()

static SECURITY_STATUS SEC_ENTRY nego_InitializeSecurityContextW ( PCredHandle  phCredential, PCtxtHandle  phContext, SEC_WCHAR *  pszTargetName, ULONG  fContextReq, ULONG  Reserved1, ULONG  TargetDataRep, PSecBufferDesc  pInput, ULONG  Reserved2, PCtxtHandle  phNewContext, PSecBufferDesc  pOutput, ULONG *  pfContextAttr, PTimeStamp  ptsExpiry  )

static

Definition at line 162 of file negotiate.c.

{
    TRACE("%p, %p, %s, 0x%08x, %u, %u, %p, %u, %p, %p, %p, %p\n",
          phCredential, phContext, debugstr_w(pszTargetName), fContextReq,
          Reserved1, TargetDataRep, pInput, Reserved1, phNewContext, pOutput,
          pfContextAttr, ptsExpiry);

    return ntlm_InitializeSecurityContextW( phCredential, phContext, pszTargetName,
                                            fContextReq, Reserved1, TargetDataRep,
                                            pInput, Reserved2, phNewContext,
                                            pOutput, pfContextAttr, ptsExpiry );
}

Referenced by nego_InitializeSecurityContextA().

nego_MakeSignature()

static SECURITY_STATUS SEC_ENTRY nego_MakeSignature ( PCtxtHandle  phContext, ULONG  fQOP, PSecBufferDesc  pMessage, ULONG  MessageSeqNo  )

static

Definition at line 380 of file negotiate.c.

{
    TRACE("%p, 0x%08x, %p, %u\n", phContext, fQOP, pMessage, MessageSeqNo);

    return ntlm_MakeSignature( phContext, fQOP, pMessage, MessageSeqNo );
}

nego_QueryContextAttributesA()

static SECURITY_STATUS SEC_ENTRY nego_QueryContextAttributesA ( PCtxtHandle  phContext, ULONG  ulAttribute, void *  pBuffer  )

static

Definition at line 311 of file negotiate.c.

{
    TRACE("%p, %u, %p\n", phContext, ulAttribute, pBuffer);

    switch (ulAttribute)
    {
    case SECPKG_ATTR_SIZES:
    {
        SecPkgContext_Sizes *sizes = (SecPkgContext_Sizes *)pBuffer;
        sizes->cbMaxToken        = 2888;
        sizes->cbMaxSignature    = 16;
        sizes->cbSecurityTrailer = 16;
        sizes->cbBlockSize       = 0;
        return SEC_E_OK;
    }
    case SECPKG_ATTR_NEGOTIATION_INFO:
    {
        SecPkgContext_NegotiationInfoA *info = (SecPkgContext_NegotiationInfoA *)pBuffer;
        info->PackageInfo      = ntlm_package_infoA;
        info->NegotiationState = SECPKG_NEGOTIATION_COMPLETE;
        return SEC_E_OK;
    }
    default:
        return ntlm_QueryContextAttributesA( phContext, ulAttribute, pBuffer );
    }
}

nego_QueryContextAttributesW()

static SECURITY_STATUS SEC_ENTRY nego_QueryContextAttributesW ( PCtxtHandle  phContext, ULONG  ulAttribute, void *  pBuffer  )

static

Definition at line 280 of file negotiate.c.

{
    TRACE("%p, %u, %p\n", phContext, ulAttribute, pBuffer);

    switch (ulAttribute)
    {
    case SECPKG_ATTR_SIZES:
    {
        SecPkgContext_Sizes *sizes = (SecPkgContext_Sizes *)pBuffer;
        sizes->cbMaxToken        = 2888;
        sizes->cbMaxSignature    = 16;
        sizes->cbSecurityTrailer = 16;
        sizes->cbBlockSize       = 0;
        return SEC_E_OK;
    }
    case SECPKG_ATTR_NEGOTIATION_INFO:
    {
        SecPkgContext_NegotiationInfoW *info = (SecPkgContext_NegotiationInfoW *)pBuffer;
        info->PackageInfo      = ntlm_package_infoW;
        info->NegotiationState = SECPKG_NEGOTIATION_COMPLETE;
        return SEC_E_OK;
    }
    default:
        return ntlm_QueryContextAttributesW( phContext, ulAttribute, pBuffer );
    }
}

nego_QueryCredentialsAttributesA()

static SECURITY_STATUS SEC_ENTRY nego_QueryCredentialsAttributesA ( PCredHandle  phCredential, ULONG  ulAttribute, PVOID  pBuffer  )

static

Definition at line 31 of file negotiate.c.

{
    FIXME("%p, %u, %p\n", phCredential, ulAttribute, pBuffer);
    return SEC_E_UNSUPPORTED_FUNCTION;
}

nego_QueryCredentialsAttributesW()

static SECURITY_STATUS SEC_ENTRY nego_QueryCredentialsAttributesW ( PCredHandle  phCredential, ULONG  ulAttribute, PVOID  pBuffer  )

static

Definition at line 41 of file negotiate.c.

{
    FIXME("%p, %u, %p\n", phCredential, ulAttribute, pBuffer);
    return SEC_E_UNSUPPORTED_FUNCTION;
}

nego_RevertSecurityContext()

static SECURITY_STATUS SEC_ENTRY nego_RevertSecurityContext ( PCtxtHandle  phContext )

static

Definition at line 361 of file negotiate.c.

{
    SECURITY_STATUS ret;

    TRACE("%p\n", phContext);
    if (phContext)
    {
        ret = SEC_E_UNSUPPORTED_FUNCTION;
    }
    else
    {
        ret = SEC_E_INVALID_HANDLE;
    }
    return ret;
}

nego_VerifySignature()

static SECURITY_STATUS SEC_ENTRY nego_VerifySignature ( PCtxtHandle  phContext, PSecBufferDesc  pMessage, ULONG  MessageSeqNo, PULONG  pfQOP  )

static

Definition at line 391 of file negotiate.c.

{
    TRACE("%p, %p, %u, %p\n", phContext, pMessage, MessageSeqNo, pfQOP);

    return ntlm_VerifySignature( phContext, pMessage, MessageSeqNo, pfQOP );
}

SECUR32_initNegotiateSP()

void SECUR32_initNegotiateSP

(

void

)

Definition at line 516 of file negotiate.c.

{
    SecureProvider *provider = SECUR32_addProvider(&negoTableA, &negoTableW, NULL);

    const SecPkgInfoW infoW = {CAPS, 1, RPC_C_AUTHN_GSS_NEGOTIATE, NEGO_MAX_TOKEN,
                               nego_name_W, negotiate_comment_W};
    const SecPkgInfoA infoA = {CAPS, 1, RPC_C_AUTHN_GSS_NEGOTIATE, NEGO_MAX_TOKEN,
                               nego_name_A, negotiate_comment_A};
    SECUR32_addPackages(provider, 1L, &infoA, &infoW);
}

Referenced by SECUR32_initializeProviders().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

secur32

)

Variable Documentation

nego_name_A

char nego_name_A[] = "Negotiate"

static

Definition at line 496 of file negotiate.c.

Referenced by SECUR32_initNegotiateSP().

nego_name_W

WCHAR nego_name_W[] = {'N','e','g','o','t','i','a','t','e',0}

static

Definition at line 495 of file negotiate.c.

Referenced by SECUR32_initNegotiateSP().

negoTableA

const SecurityFunctionTableA negoTableA

static

Initial value:

= {
    1,
    NULL,                               
    nego_QueryCredentialsAttributesA,   
    nego_AcquireCredentialsHandleA,     
    nego_FreeCredentialsHandle,         
    NULL,                               
    nego_InitializeSecurityContextA,    
    nego_AcceptSecurityContext,         
    nego_CompleteAuthToken,             
    nego_DeleteSecurityContext,         
    nego_ApplyControlToken,             
    nego_QueryContextAttributesA,       
    nego_ImpersonateSecurityContext,    
    nego_RevertSecurityContext,         
    nego_MakeSignature,                 
    nego_VerifySignature,               
    FreeContextBuffer,                  
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    nego_EncryptMessage,                
    nego_DecryptMessage,                
    NULL,   
}

Definition at line 431 of file negotiate.c.

Referenced by SECUR32_initNegotiateSP().

negoTableW

const SecurityFunctionTableW negoTableW

static

Initial value:

= {
    1,
    NULL,                               
    nego_QueryCredentialsAttributesW,   
    nego_AcquireCredentialsHandleW,     
    nego_FreeCredentialsHandle,         
    NULL,                               
    nego_InitializeSecurityContextW,    
    nego_AcceptSecurityContext,         
    nego_CompleteAuthToken,             
    nego_DeleteSecurityContext,         
    nego_ApplyControlToken,             
    nego_QueryContextAttributesW,       
    nego_ImpersonateSecurityContext,    
    nego_RevertSecurityContext,         
    nego_MakeSignature,                 
    nego_VerifySignature,               
    FreeContextBuffer,                  
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    NULL,   
    nego_EncryptMessage,                
    nego_DecryptMessage,                
    NULL,   
}

Definition at line 462 of file negotiate.c.

Referenced by SECUR32_initNegotiateSP().

negotiate_comment_A

CHAR negotiate_comment_A[] = "Microsoft Package Negotiator"

static

Definition at line 501 of file negotiate.c.

Referenced by SECUR32_initNegotiateSP().

negotiate_comment_W

WCHAR negotiate_comment_W[]

static

Initial value:

=
    {'M','i','c','r','o','s','o','f','t',' ','P','a','c','k','a','g','e',' ',
     'N','e','g','o','t','i','a','t','o','r',0}

Definition at line 498 of file negotiate.c.

Referenced by SECUR32_initNegotiateSP().