helpers/negotiate_auth/squid_kerb_auth/spnegohelp/spnegoparse.h

   1 // Copyright (C) 2002 Microsoft Corporation
   2 // All rights reserved.
   3 //
   4 // THIS CODE AND INFORMATION IS PROVIDED "AS IS"
   5 // WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
   6 // OR IMPLIED, INCLUDING BUT NOT LIMITED
   7 // TO THE IMPLIED WARRANTIES OF MERCHANTIBILITY
   8 // AND/OR FITNESS FOR A PARTICULAR PURPOSE.
   9 //
  10 // Date    - 10/08/2002
  11 // Author  - Sanj Surati
  12
  13 /////////////////////////////////////////////////////////////
  14 //
  15 // SPNEGOPARSE.H
  16 //
  17 // SPNEGO Token Parser Header File
  18 //
  19 // Contains the definitions required to properly parse a
  20 // SPNEGO token using ASN.1 DER helpers.
  21 //
  22 /////////////////////////////////////////////////////////////
  23
  24 #ifndef __SPNEGOPARSE_H__
  25 #define __SPNEGOPARSE_H__
  26
  27 // C++ Specific
  28 #if defined(__cplusplus)
  29 extern "C"
  30 {
  31 #endif
  32
  33 // Indicates if we copy data when creating a SPNEGO_TOKEN structure or not
  34 #define SPNEGO_TOKEN_INTERNAL_COPYPTR           0
  35 #define SPNEGO_TOKEN_INTERNAL_COPYDATA          0x1
  36
  37 // Internal flag dictates whether or not we will free the binary data when
  38 // the SPNEG_TOKEN structure is destroyed
  39 #define  SPNEGO_TOKEN_INTERNAL_FLAGS_FREEDATA   0x1
  40
  41     //
  42 // Each SPNEGO Token Type can be broken down into a
  43 // maximum of 4 separate elements.
  44 //
  45
  46 #define  MAX_NUM_TOKEN_ELEMENTS  4
  47
  48 //
  49 // Element offsets in the array
  50 //
  51
  52 // INIT elements
  53 #define  SPNEGO_INIT_MECHTYPES_ELEMENT    0
  54 #define  SPNEGO_INIT_REQFLAGS_ELEMENT     1
  55 #define  SPNEGO_INIT_MECHTOKEN_ELEMENT    2
  56 #define  SPNEGO_INIT_MECHLISTMIC_ELEMENT  3
  57
  58 // Response elements
  59 #define  SPNEGO_TARG_NEGRESULT_ELEMENT    0
  60 #define  SPNEGO_TARG_SUPPMECH_ELEMENT     1
  61 #define  SPNEGO_TARG_RESPTOKEN_ELEMENT    2
  62 #define  SPNEGO_TARG_MECHLISTMIC_ELEMENT  3
  63
  64 //
  65 // Defines an individual SPNEGO Token Element.
  66 //
  67
  68     typedef struct SpnegoElement {
  69         size_t                nStructSize;        // Size of the element structure
  70         int                   iElementPresent;    // Is the field present?  Must be either
  71         // SPNEGO_TOKEN_ELEMENT_UNAVAILABLE or
  72         // SPNEGO_TOKEN_ELEMENT_AVAILABLE
  73
  74         SPNEGO_ELEMENT_TYPE   eElementType;       // The Element Type
  75
  76         unsigned char         type;               // Data Type
  77
  78         unsigned char*        pbData;             // Points to actual Data
  79
  80         unsigned long         nDatalength;        // Actual Data Length
  81
  82     } SPNEGO_ELEMENT;
  83
  84 // Structure size in case we later choose to extend the structure
  85 #define  SPNEGO_ELEMENT_SIZE sizeof(SPNEGO_ELEMENT)
  86
  87 //
  88 // Packages a SPNEGO Token Encoding.  There are two types of
  89 // encodings: NegTokenInit and NegTokenTarg.  Each encoding can
  90 // contain up to four distinct, optional elements.
  91 //
  92
  93     typedef struct SpnegoToken {
  94         size_t            nStructSize;                              // Size of the Token structure
  95         unsigned long     ulFlags;                                  // Internal Structure Flags - Reserved!
  96         int               ucTokenType;                              // Token Type - Must be
  97         // SPNEGO_TOKEN_INIT or
  98         // SPNEGO_TOKEN_TARG
  99
 100         unsigned char*    pbBinaryData;                             // Points to binary token data
 101
 102         unsigned long     ulBinaryDataLen;                          // Length of the actual binary data
 103         int               nNumElements;                             // Number of elements
 104         SPNEGO_ELEMENT    aElementArray [MAX_NUM_TOKEN_ELEMENTS];   // Holds the elements for the token
 105     } SPNEGO_TOKEN;
 106
 107 // Structure size in case we later choose to extend the structure
 108 #define  SPNEGO_TOKEN_SIZE sizeof(SPNEGO_TOKEN)
 109
 110 //
 111 // Function definitions
 112 //
 113
 114     SPNEGO_TOKEN* AllocEmptySpnegoToken( unsigned char ucCopyData, unsigned long ulFlags,
 115                                          unsigned char * pbTokenData, unsigned long ulTokenSize );
 116     void FreeSpnegoToken( SPNEGO_TOKEN* pSpnegoToken );
 117     void InitSpnegoTokenElementArray( SPNEGO_TOKEN* pSpnegoToken );
 118     int InitSpnegoTokenType( SPNEGO_TOKEN* pSpnegoToken, long* pnTokenLength,
 119                              long* pnRemainingTokenLength, unsigned char** ppbFirstElement );
 120     int InitSpnegoTokenElements( SPNEGO_TOKEN* pSpnegoToken, unsigned char* pbTokenData,
 121                                  long nRemainingTokenLength  );
 122     int GetSpnegoInitTokenMechList( unsigned char* pbTokenData, int nMechListLength,
 123                                     SPNEGO_ELEMENT* pSpnegoElement );
 124     int InitSpnegoTokenElementFromBasicType( unsigned char* pbTokenData, int nElementLength,
 125             unsigned char ucExpectedType,
 126             SPNEGO_ELEMENT_TYPE spnegoElementType,
 127             SPNEGO_ELEMENT* pSpnegoElement );
 128     int InitSpnegoTokenElementFromOID( unsigned char* pbTokenData, int nElementLength,
 129                                        SPNEGO_ELEMENT_TYPE spnegoElementType,
 130                                        SPNEGO_ELEMENT* pSpnegoElement );
 131     int FindMechOIDInMechList( SPNEGO_ELEMENT* pSpnegoElement, SPNEGO_MECH_OID MechOID,
 132                                int * piMechTypeIndex );
 133     int ValidateMechList( unsigned char* pbMechListData, long nBoundaryLength );
 134     int CalculateMinSpnegoInitTokenSize( long nMechTokenLength, long nMechListMICLength,
 135                                          SPNEGO_MECH_OID mechOid, int nReqFlagsAvailable,
 136                                          long* plTokenSize, long* plInternalLength );
 137     int CalculateMinSpnegoTargTokenSize( SPNEGO_MECH_OID MechType, SPNEGO_NEGRESULT spnegoNegResult,
 138                                          long nMechTokenLen,
 139                                          long nMechTokenMIC, long* pnTokenSize,
 140                                          long* pnInternalTokenLength );
 141     int CreateSpnegoInitToken( SPNEGO_MECH_OID MechType,
 142                                unsigned char ucContextFlags, unsigned char* pbMechToken,
 143                                unsigned long ulMechTokenLen, unsigned char* pbMechListMIC,
 144                                unsigned long ulMechListMICLen, unsigned char* pbTokenData,
 145                                long nTokenLength, long nInternalTokenLength );
 146     int CreateSpnegoTargToken( SPNEGO_MECH_OID MechType,
 147                                SPNEGO_NEGRESULT eNegResult, unsigned char* pbMechToken,
 148                                unsigned long ulMechTokenLen, unsigned char* pbMechListMIC,
 149                                unsigned long ulMechListMICLen, unsigned char* pbTokenData,
 150                                long nTokenLength, long nInternalTokenLength );
 151     int IsValidMechOid( SPNEGO_MECH_OID mechOid );
 152     int IsValidContextFlags( unsigned char ucContextFlags );
 153     int IsValidNegResult( SPNEGO_NEGRESULT negResult );
 154     int IsValidSpnegoToken( SPNEGO_TOKEN* pSpnegoToken );
 155     int IsValidSpnegoElement( SPNEGO_TOKEN* pSpnegoToken,SPNEGO_ELEMENT_TYPE spnegoElement );
 156     int CalculateElementArrayIndex( SPNEGO_TOKEN* pSpnegoToken,SPNEGO_ELEMENT_TYPE spnegoElement );
 157     int InitTokenFromBinary( unsigned char ucCopyData, unsigned long ulFlags,
 158                              unsigned char* pbTokenData, unsigned long ulLength,
 159                              SPNEGO_TOKEN** ppSpnegoToken );
 160
 161     // C++ Specific
 162 #if defined(__cplusplus)
 163 }
 164 #endif
 165
 166 #endif
 167