// Copyright (C) 2002 Microsoft Corporation// All rights reserved.//// THIS CODE AND INFORMATION IS PROVIDED "AS IS"// WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED// OR IMPLIED, INCLUDING BUT NOT LIMITED// TO THE IMPLIED WARRANTIES OF MERCHANTIBILITY// AND/OR FITNESS FOR A PARTICULAR PURPOSE.//// Date    - 10/08/2002// Author  - Sanj Surati///////////////////////////////////////////////////////////////// SPNEGO.C//// SPNEGO Token Handler Source File//// Contains implementation of SPNEGO Token Handling API// as defined in SPNEGO.H.///////////////////////////////////////////////////////////////#include <stdlib.h>#include <stdio.h>#include <memory.h>#include "spnego.h"#include "derparse.h"#include "spnegoparse.h"//// Defined in DERPARSE.C//extern MECH_OID g_stcMechOIDList [];/**********************************************************************//**                                                                  **//**                                                                  **//**                                                                  **//**                                                                  **//**               SPNEGO Token Handler API implementation            **//**                                                                  **//**                                                                  **//**                                                                  **//**                                                                  **//**********************************************************************////////////////////////////////////////////////////////////////////////////////// Function://    spnegoInitFromBinary//// Parameters://    [in]  pbTokenData       -  Binary Token Data//    [in]  ulLength          -  Length of binary Token Data//    [out] phSpnegoToken     -  SPNEGO_TOKEN_HANDLE pointer//// Returns://    int   Success - SPNEGO_E_SUCCESS//          Failure - SPNEGO API Error code//// Comments ://    Initializes a SPNEGO_TOKEN_HANDLE from the supplied//    binary data.  Data is copied locally.  Returned data structure//    must be freed by calling spnegoFreeData().//////////////////////////////////////////////////////////////////////////////int spnegoInitFromBinary( unsigned char* pbTokenData, unsigned long ulLength, SPNEGO_TOKEN_HANDLE* phSpnegoToken ){   int            nReturn = SPNEGO_E_INVALID_PARAMETER;   SPNEGO_TOKEN** ppSpnegoToken = (SPNEGO_TOKEN**) phSpnegoToken;   // Pass off to a handler function that allows tighter control over how the token structure   // is handled.  In this case, we want the token data copied and we want the associated buffer   // freed.   nReturn = InitTokenFromBinary( SPNEGO_TOKEN_INTERNAL_COPYDATA,                                 SPNEGO_TOKEN_INTERNAL_FLAGS_FREEDATA, pbTokenData,                                 ulLength, ppSpnegoToken );   LOG(("spnegoInitFromBinary returned %d\n",nReturn));   return nReturn;}///////////////////////////////////////////////////////////////////////////////// Function://    spnegoCreateNegTokenInit//// Parameters://    [in]  MechType          -  MechType to specify in MechTypeList element//    [in]  ucContextFlags    -  Context Flags element value//    [in]  pbMechToken       -  Pointer to binary MechToken Data//    [in]  ulMechTokenLen    -  Length of MechToken Data//    [in]  pbMechListMIC     -  Pointer to binary MechListMIC Data//    [in]  ulMechListMICLen  -  Length of MechListMIC Data//    [out] phSpnegoToken     -  SPNEGO_TOKEN_HANDLE pointer//// Returns://    int   Success - SPNEGO_E_SUCCESS//          Failure - SPNEGO API Error code//// Comments ://    Initializes a SPNEGO_TOKEN_HANDLE for a NegTokenInit type//    from the supplied parameters.  ucContextFlags may be 0 or must be//    a valid flag combination.  MechToken data can be NULL - if not, it//    must correspond to the MechType.  MechListMIC can also be NULL.//    Returned data structure must be freed by calling spnegoFreeData().//////////////////////////////////////////////////////////////////////////////int spnegoCreateNegTokenInit( SPNEGO_MECH_OID MechType,          unsigned char ucContextFlags, unsigned char* pbMechToken,          unsigned long ulMechTokenLen, unsigned char* pbMechListMIC,          unsigned long ulMechListMICLen, SPNEGO_TOKEN_HANDLE* phSpnegoToken ){   int   nReturn = SPNEGO_E_INVALID_PARAMETER;   long  nTokenLength = 0L;   long  nInternalTokenLength = 0L;   unsigned char* pbTokenData = NULL;   SPNEGO_TOKEN** ppSpnegoToken = (SPNEGO_TOKEN**) phSpnegoToken;   if ( NULL != ppSpnegoToken &&         IsValidMechOid( MechType ) &&         IsValidContextFlags( ucContextFlags ) )   {      // Get the actual token size      if ( ( nReturn = CalculateMinSpnegoInitTokenSize( ulMechTokenLen, ulMechListMICLen,                                                          MechType, ( ucContextFlags != 0L ),                                                          &nTokenLength, &nInternalTokenLength ) )                        == SPNEGO_E_SUCCESS )      {         // Allocate a buffer to hold the data.         pbTokenData = calloc( 1, nTokenLength );         if ( NULL != pbTokenData )         {            // Now write the token            if ( ( nReturn = CreateSpnegoInitToken( MechType,                                                 ucContextFlags, pbMechToken,                                                 ulMechTokenLen, pbMechListMIC,                                                 ulMechListMICLen, pbTokenData,                                                 nTokenLength, nInternalTokenLength ) )                              == SPNEGO_E_SUCCESS )            {               // This will copy our allocated pointer, and ensure that the sructure cleans               // up the data later               nReturn = InitTokenFromBinary( SPNEGO_TOKEN_INTERNAL_COPYPTR,                                             SPNEGO_TOKEN_INTERNAL_FLAGS_FREEDATA,                                             pbTokenData, nTokenLength, ppSpnegoToken );            }            // Cleanup on failure            if ( SPNEGO_E_SUCCESS != nReturn )            {               free( pbTokenData );            }         }  // IF alloc succeeded         else         {            nReturn = SPNEGO_E_OUT_OF_MEMORY;         }      }  // If calculated token size   }  // IF Valid Parameters   LOG(("spnegoCreateNegTokenInit returned %d\n",nReturn));   return nReturn;}///////////////////////////////////////////////////////////////////////////////// Function://    spnegoCreateNegTokenTarg//// Parameters://    [in]  MechType          -  MechType to specify in supported MechType element//    [in]  spnegoNegResult   -  NegResult value//    [in]  pbMechToken       -  Pointer to response MechToken Data//    [in]  ulMechTokenLen    -  Length of MechToken Data//    [in]  pbMechListMIC     -  Pointer to binary MechListMIC Data//    [in]  ulMechListMICLen  -  Length of MechListMIC Data//    [out] phSpnegoToken     -  SPNEGO_TOKEN_HANDLE pointer//// Returns://    int   Success - SPNEGO_E_SUCCESS//          Failure - SPNEGO API Error code//// Comments ://    Initializes a SPNEGO_TOKEN_HANDLE for a NegTokenTarg type//    from the supplied parameters.  MechToken data can be NULL - if not,//    it must correspond to the MechType.  MechListMIC can also be NULL.//    Returned data structure must be freed by calling spnegoFreeData().//////////////////////////////////////////////////////////////////////////////int spnegoCreateNegTokenTarg( SPNEGO_MECH_OID MechType,           SPNEGO_NEGRESULT spnegoNegResult, unsigned char* pbMechToken,          unsigned long ulMechTokenLen, unsigned char* pbMechListMIC,          unsigned long ulMechListMICLen, SPNEGO_TOKEN_HANDLE* phSpnegoToken ){   int   nReturn = SPNEGO_E_INVALID_PARAMETER;   long  nTokenLength = 0L;   long  nInternalTokenLength = 0L;   unsigned char* pbTokenData = NULL;   SPNEGO_TOKEN** ppSpnegoToken = (SPNEGO_TOKEN**) phSpnegoToken;   //   // spnego_mech_oid_NotUsed and spnego_negresult_NotUsed   // are okay here, however a valid MechOid is required   // if spnego_negresult_success or spnego_negresult_incomplete   // is specified.   //   if ( NULL != ppSpnegoToken &&         ( IsValidMechOid( MechType ) ||            spnego_mech_oid_NotUsed == MechType ) &&         ( IsValidNegResult( spnegoNegResult ) ||            spnego_negresult_NotUsed == spnegoNegResult ) &&         !( !IsValidMechOid( MechType ) &&            ( spnego_negresult_success == spnegoNegResult ||              spnego_negresult_incomplete == spnegoNegResult ) ) )   {      // Get the actual token size      if ( ( nReturn = CalculateMinSpnegoTargTokenSize( MechType, spnegoNegResult, ulMechTokenLen,                                                         ulMechListMICLen, &nTokenLength,                                                          &nInternalTokenLength ) )                        == SPNEGO_E_SUCCESS )      {         // Allocate a buffer to hold the data.         pbTokenData = calloc( 1, nTokenLength );         if ( NULL != pbTokenData )         {            // Now write the token            if ( ( nReturn = CreateSpnegoTargToken( MechType,                                                 spnegoNegResult, pbMechToken,                                                 ulMechTokenLen, pbMechListMIC,                                                 ulMechListMICLen, pbTokenData,                                                 nTokenLength, nInternalTokenLength ) )                              == SPNEGO_E_SUCCESS )            {               // This will copy our allocated pointer, and ensure that the sructure cleans               // up the data later               nReturn = InitTokenFromBinary( SPNEGO_TOKEN_INTERNAL_COPYPTR,                                             SPNEGO_TOKEN_INTERNAL_FLAGS_FREEDATA,                                             pbTokenData, nTokenLength, ppSpnegoToken );            }            // Cleanup on failure            if ( SPNEGO_E_SUCCESS != nReturn )            {               free( pbTokenData );            }         }  // IF alloc succeeded         else         {            nReturn = SPNEGO_E_OUT_OF_MEMORY;         }      }  // If calculated token size   }  // IF Valid Parameters   LOG(("spnegoCreateNegTokenTarg returned %d\n",nReturn));   return nReturn;}///////////////////////////////////////////////////////////////////////////////// Function://    spnegoTokenGetBinary//// Parameters://    [in]     hSpnegoToken   -  Initialized SPNEGO_TOKEN_HANDLE//    [out]    pbTokenData    -  Buffer to copy token into//    [in/out] pulDataLen     -  Length of pbTokenData buffer, filled out//                               with actual size used upon function return.//// Returns://    int   Success - SPNEGO_E_SUCCESS//          Failure - SPNEGO API Error code//// Comments ://    Copies binary SPNEGO token data from hSpnegoToken into the user//    supplied buffer.  If pbTokenData is NULL, or the value in pulDataLen//    is too small, the function will return SPNEGO_E_BUFFER_TOO_SMALL and//    fill out pulDataLen with the minimum required buffer size.//////////////////////////////////////////////////////////////////////////////int spnegoTokenGetBinary( SPNEGO_TOKEN_HANDLE hSpnegoToken, unsigned char* pbTokenData,                           unsigned long * pulDataLen ){   int   nReturn = SPNEGO_E_INVALID_PARAMETER;   SPNEGO_TOKEN*  pSpnegoToken = (SPNEGO_TOKEN*) hSpnegoToken;      // Check parameters - pbTokenData is optional   if (  IsValidSpnegoToken( pSpnegoToken ) &&         NULL != pulDataLen )   {      // Check for Buffer too small conditions      if ( NULL == pbTokenData ||            pSpnegoToken->ulBinaryDataLen > *pulDataLen )      {         *pulDataLen = pSpnegoToken->ulBinaryDataLen;         nReturn = SPNEGO_E_BUFFER_TOO_SMALL;      }      else      {         memcpy( pbTokenData, pSpnegoToken->pbBinaryData, pSpnegoToken->ulBinaryDataLen );         *pulDataLen = pSpnegoToken->ulBinaryDataLen;         nReturn = SPNEGO_E_SUCCESS;      }   }  // IF parameters OK   LOG(("spnegoTokenGetBinary returned %d\n",nReturn));   return nReturn;;}///////////////////////////////////////////////////////////////////////////////// Function://    spnegoFreeData//// Parameters://    [in]     hSpnegoToken   -  Initialized SPNEGO_TOKEN_HANDLE//// Returns://    void//// Comments ://    Frees up resources consumed by hSpnegoToken.  The supplied data//    pointer is invalidated by this function.//////////////////////////////////////////////////////////////////////////////void spnegoFreeData( SPNEGO_TOKEN_HANDLE hSpnegoToken ){   FreeSpnegoToken( (SPNEGO_TOKEN*) hSpnegoToken);   return;}///////////////////////////////////////////////////////////////////////////////// Function://    spnegoGetTokenType//// Parameters://    [in]  hSpnegoToken      -  Initialized SPNEGO_TOKEN_HANDLE//    [out] piTokenType       -  Filled out with token type value.//// Returns://    int   Success - SPNEGO_E_SUCCESS//          Failure - SPNEGO API Error code//// Comments ://    The function will analyze hSpnegoToken and return the appropriate//    type in piTokenType.//////////////////////////////////////////////////////////////////////////////int spnegoGetTokenType( SPNEGO_TOKEN_HANDLE hSpnegoToken, int * piTokenType ){   int   nReturn = SPNEGO_E_INVALID_PARAMETER;   SPNEGO_TOKEN*  pSpnegoToken = (SPNEGO_TOKEN*) hSpnegoToken;      // Check parameters   if (  IsValidSpnegoToken( pSpnegoToken ) &&         NULL != piTokenType &&         pSpnegoToken)   {      // Check that the type in the structure makes sense      if ( SPNEGO_TOKEN_INIT == pSpnegoToken->ucTokenType ||            SPNEGO_TOKEN_TARG == pSpnegoToken->ucTokenType )      {         *piTokenType = pSpnegoToken->ucTokenType;         nReturn = SPNEGO_E_SUCCESS;      }   }  // IF parameters OK   LOG(("spnegoGetTokenType returned %d\n",nReturn));