sspi for NTLM or Kerberos

 

代码

  1  /*
  2  You can get a locally valid logon session (a network logon session) by using SSPI.
  3  Simply specify alternate credentials when you call AcquireCredentialsHandle,
  4  and then after you follow the normal InitializeSecurityContext/AcceptSecurityContext
  5  handshake, you'll end up with a logon session for the user,
  6  without having to have the TCB privilege.
  7 
  8  See the attached example...
  9 
 10  Keith
 11     */
 12 
 13  //  this version requires Windows 2000
 14  #define  _WIN32_WINNT 0x500
 15  #define  UNICODE
 16  #include  < windows.h >
 17  #include  < stdio.h >
 18  #define  SECURITY_WIN32
 19  #include  < security.h >
 20  #pragma  comment(lib, "secur32.lib")
 21 
 22  //  brain-dead error routine that dumps the last error and exits
 23  void  _err( const  wchar_t *  pszFcn, DWORD nErr  =  GetLastError())
 24  {
 25   
 26      wchar_t szErr[ 256 ];
 27       if  (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,  0 , nErr,  0 ,
 28                        szErr,  sizeof  szErr  /   sizeof   * szErr,  0 ))
 29           wprintf(L " %s failed: %s " , pszFcn, szErr);
 30       else  wprintf(L " %s failed: 0x%08X " , nErr);
 31      exit( 1 );
 32  }
 33 
 34  //  Upon success, returns a handle to a NETWORK logon session
 35  //  for the specified principal (it will *not* have network
 36  //  credentials). Call CloseHandle to dispose of it when
 37  //  you are finished.
 38  HANDLE _logonUserWithSSPI(wchar_t *  pszSSP,
 39                            DWORD grfDesiredAccessToToken,
 40                            wchar_t *  pszAuthority,
 41                            wchar_t *  pszPrincipal,
 42                            wchar_t *  pszPassword) {
 43 
 44       //  the following code loads the SSPI interface DLL
 45       //  and initializes it, getting a table of function ptrs
 46      HINSTANCE hdll  =  LoadLibrary(L " security.dll " );
 47       if  ( ! hdll)
 48          _err(L " LoadLibrary " );
 49      INIT_SECURITY_INTERFACE_W initSecurityInterface  =
 50              (INIT_SECURITY_INTERFACE_W)GetProcAddress(hdll,
 51                  SECURITY_ENTRYPOINT_ANSIW);
 52       if  ( ! initSecurityInterface)
 53          _err(L " GetProcAddress " );
 54      PSecurityFunctionTable pSSPI  =  initSecurityInterface();
 55 
 56       //  here's where we specify the credentials to verify
 57      SEC_WINNT_AUTH_IDENTITY_EX authIdent  =  {
 58          SEC_WINNT_AUTH_IDENTITY_VERSION,
 59           sizeof  authIdent,
 60          pszPrincipal, lstrlenW(pszPrincipal),
 61          pszAuthority, lstrlenW(pszAuthority),
 62          pszPassword,  lstrlenW(pszPassword),
 63          SEC_WINNT_AUTH_IDENTITY_UNICODE,
 64           0 ,  0
 65      };
 66 
 67       //  get an SSPI handle for these credentials
 68      CredHandle hcredClient;
 69      TimeStamp expiryClient;
 70      SECURITY_STATUS err  =
 71          pSSPI -> AcquireCredentialsHandle( 0 , pszSSP,
 72                                          SECPKG_CRED_OUTBOUND,
 73                                           0 ,  & authIdent,
 74                                           0 ,  0 ,
 75                                           & hcredClient,
 76                                           & expiryClient);
 77       if  (err)
 78          _err(L " AcquireCredentialsHandle for client " , err);
 79 
 80       //  use the caller's credentials for the server
 81      CredHandle hcredServer;
 82      TimeStamp expiryServer;
 83      err  =  pSSPI -> AcquireCredentialsHandle( 0 , pszSSP,
 84                                            SECPKG_CRED_INBOUND,
 85                                             0 ,  0 ,  0 ,  0 ,
 86                                             & hcredServer,
 87                                             & expiryServer);
 88       if  (err)
 89          _err(L " AcquireCredentialsHandle for server " , err);
 90 
 91      CtxtHandle hctxClient;
 92      CtxtHandle hctxServer;
 93 
 94       //  create two buffers:
 95       //     one for the client sending tokens to the server,
 96       //     one for the server sending tokens to the client
 97       //  (buffer size chosen based on current Kerb SSP setting
 98       //   for cbMaxToken - you may need to adjust this)
 99      BYTE bufC2S[ 8000 ];
100      BYTE bufS2C[ 8000 ];
101      SecBuffer sbufC2S  =  {  sizeof  bufC2S, SECBUFFER_TOKEN, bufC2S };
102      SecBuffer sbufS2C  =  {  sizeof  bufS2C, SECBUFFER_TOKEN, bufS2C };
103      SecBufferDesc bdC2S  =  { SECBUFFER_VERSION,  1 ,  & sbufC2S };
104      SecBufferDesc bdS2C  =  { SECBUFFER_VERSION,  1 ,  & sbufS2C };
105 
106       //  don't really need any special context attributes
107      DWORD grfRequiredCtxAttrsClient  =  ISC_REQ_DATAGRAM; // ISC_REQ_DELEGATE
108      DWORD grfRequiredCtxAttrsServer  =  ASC_REQ_DATAGRAM;
109 
110       //  set up some aliases to make it obvious what's happening
111      PCtxtHandle    pClientCtxHandleIn   =   0 ;
112      PCtxtHandle    pClientCtxHandleOut  =   & hctxClient;
113      PCtxtHandle    pServerCtxHandleIn   =   0 ;
114      PCtxtHandle    pServerCtxHandleOut  =   & hctxServer;
115      SecBufferDesc *  pClientInput   =   0 ;
116      SecBufferDesc *  pClientOutput  =   & bdC2S;
117      SecBufferDesc *  pServerInput   =   & bdC2S;
118      SecBufferDesc *  pServerOutput  =   & bdS2C;
119      DWORD          grfCtxAttrsClient  =   0 ;
120      DWORD          grfCtxAttrsServer  =   0 ;
121      TimeStamp      expiryClientCtx;
122      TimeStamp      expiryServerCtx;
123 
124       //  since the caller is acting as the server, we need
125       //  a server principal name so that the client will
126       //  be able to get a Kerb ticket (if Kerb is used)
127      wchar_t szSPN[ 256 ] = { 0 };
128      ULONG cchSPN  =   sizeof  szSPN  /   sizeof   * szSPN;
129      GetUserNameEx(NameSamCompatible, szSPN,  & cchSPN);
130   
131    // sevice class / host: port / service instance
132   
133  //  wcscpy (szSPN, TEXT("192.168.1.11"));
134  //  wcscpy (szSPN, TEXT("testwork-AD11.testwork.com"));
135  //  wcscpy (szSPN, TEXT("192.168.1.11"));
136  //  wcscpy (szSPN, TEXT("TESTWORK\\administrator"));
137  //  wcscpy (szSPN, TEXT("..."));
138   printf( " %ws\n " ,szSPN);
139       //  perform the authentication handshake, playing the
140       //  role of both client *and* server.
141       bool  bClientContinue  =   true ;
142       bool  bServerContinue  =   true ;
143    int  count = 1 ;
144       while  (bClientContinue  ||  bServerContinue) {
145    
146           if  (bClientContinue) {
147     
148              sbufC2S.cbBuffer  =   sizeof  bufC2S;
149              err  =  pSSPI -> InitializeSecurityContext(
150                   & hcredClient, pClientCtxHandleIn,
151                  szSPN,
152                  grfRequiredCtxAttrsClient,
153                   0 , SECURITY_NETWORK_DREP,
154                  pClientInput,  0 ,
155                  pClientCtxHandleOut,
156                  pClientOutput,
157                   & grfCtxAttrsClient,
158                   & expiryClientCtx);
159               switch  (err) {
160                   case   0 :
161                      bClientContinue  =   false ;
162                       break ;
163                   case  SEC_I_CONTINUE_NEEDED:
164                      pClientCtxHandleIn  =  pClientCtxHandleOut;
165                      pClientInput        =  pServerOutput;
166                       break ;
167                   default :
168       printf( " err=%x\n " ,err);
169                      _err(L " InitializeSecurityContext " , err);
170              }
171          }
172 
173           if  (bServerContinue) {
174              sbufS2C.cbBuffer  =   sizeof  bufS2C;
175              err  =  pSSPI -> AcceptSecurityContext(
176                   & hcredServer, pServerCtxHandleIn,
177                  pServerInput,
178                  grfRequiredCtxAttrsServer,
179                  SECURITY_NETWORK_DREP,
180                  pServerCtxHandleOut,
181                  pServerOutput,
182                   & grfCtxAttrsServer,
183                   & expiryServerCtx);
184               switch  (err) {
185                   case   0 :
186                      bServerContinue  =   false ;
187                       break ;
188                   case  SEC_I_CONTINUE_NEEDED:
189                      pServerCtxHandleIn  =  pServerCtxHandleOut;
190                       break ;
191                   default :
192                      _err(L " AcceptSecurityContext " , err);
193              }
194          }
195    printf( " %d bClientContinue %d bServerContinue %d\n " ,count ++ ,bClientContinue,bServerContinue);
196      }
197       //  if everything has gone smoothly, we've now got a logon
198       //  session for the client - let's grab the token now
199      pSSPI -> ImpersonateSecurityContext(pServerCtxHandleOut);
200      HANDLE htok;
201       if  ( ! OpenThreadToken(GetCurrentThread(),
202                           grfDesiredAccessToToken,
203                           TRUE,  & htok))
204          _err(L " OpenThreadToken " );
205      pSSPI -> RevertSecurityContext(pServerCtxHandleOut);
206 
207       //  clean up
208      pSSPI -> FreeCredentialsHandle( & hcredClient);
209      pSSPI -> FreeCredentialsHandle( & hcredServer);
210      pSSPI -> DeleteSecurityContext(pServerCtxHandleOut);
211      pSSPI -> DeleteSecurityContext(pClientCtxHandleOut);
212      
213       return  htok;
214  }
215 
216  //  here's an example of usage
217  void  main() {
218       //  use "NTLM" or "Kerberos"
219 
220  // Kerbero需要在加入域或者有域环境下才能正确运行
221      HANDLE htok  =  _logonUserWithSSPI(L " Kerberos " ,
222                                       TOKEN_QUERY,
223                                       NULL,
224                                       L " administrator " ,
225                                       L " !QAZsx " );
226       if  (htok) {
227           //  password is valid!
228          CloseHandle(htok);
229      }
230  }
231 
232