Sdílet prostřednictvím

Příklad: Použití kódování ověřování SSPI se službou BITS

Pomocí metod SSPI (Security Support Provider Interface) a služby BITS (Background Intelligent Transfer Service) můžete získat přihlašovací údaje od uživatele, zakódovat přihlašovací údaje a nastavit zakódované přihlašovací údaje pro úlohu přenosu SLUŽBY BITS. Kódování se vyžaduje k převodu struktury přihlašovacích údajů na řetězce, které je možné předat úloze přenosu SLUŽBY BITS.

Další informace o ověřování a metodách SSPI naleznete v tématu SSPI.

Následující postup vyzve uživatele k zadání přihlašovacích údajů pomocí balíčku zabezpečení Negotiate. Program vytvoří strukturu identity ověřování a naplní strukturu kódovanými řetězci, které představují uživatelské jméno, doménu a heslo uživatele. Potom program vytvoří úlohu stažení služby BITS a nastaví kódované uživatelské jméno a heslo jako přihlašovací údaje pro úlohu. Program uvolní strukturu identity ověřování, jakmile už ji nepotřebujete.

Tento příklad používá hlavičku a implementaci definovanou v Příklad: Běžné třídy.

použití kódování ověřování SSPI s úlohami přenosu služby BITS

  1. Inicializace parametrů modelu COM voláním funkce CCoInitializer. Další informace o funkci CCoInitializer naleznete v tématu Příklad: Běžné třídy.
  2. Získejte ukazatele pro IBackgroundCopyManager, IBackgroundCopyJob, IBackgroundCopyJob2 rozhraní. Tento příklad používá CComPtr Třída ke správě ukazatelů rozhraní MODELU COM.
  3. Vytvořte CREDUI_INFO strukturu, která obsahuje informace pro přizpůsobení vzhledu dialogového okna pro SspiPromptForCredentials Function. Pak se zobrazí výzva k zadání přihlašovacích údajů od uživatele. Další informace naleznete v SspiPromptForCredentials Function.
  4. Zakódujte strukturu přihlašovacích údajů jako řetězce, které lze předat úloze přenosu SLUŽBY BITS pomocí funkce SspiEncodeAuthIdentityAsStrings.
  5. Příprava struktury BG_AUTH_CREDENTIALS
  6. Inicializace zabezpečení procesu COM voláním CoInitializeSecurity. Služba BITS vyžaduje alespoň úroveň zosobnění zosobnění. Služba BITS selže s E_ACCESSDENIED, pokud není nastavená správná úroveň zosobnění.
  7. Získejte počáteční lokátor služby BITS voláním funkce CoCreateInstance.
  8. Vytvořte úlohu přenosu SLUŽBY BITS voláním metody IBackgroundCopyManager::CreateJob.
  9. Získejte identifikátor rozhraní IBackgroundCopyJob2 a volejte metodu IBackgroundCopyJob::QueryInterface.
  10. Naplňte strukturu BG_AUTH_CREDENTIALS kódovanými uživatelskými jmény a řetězci hesel a nastavte schéma ověřování na Negotiate (BG_AUTH_SCHEME_NEGOTIATE).
  11. Pomocí ukazatele IBackgroundCopyJob2 proveďte požadavky na SLUŽBU BITS. Tento program používá IBackgroundCopyJob2::SetCredentials metoda k nastavení přihlašovacích údajů pro úlohu přenosu BITS.
  12. Přidejte soubory, upravte vlastnosti nebo obnovte úlohu přenosu služby BITS.
  13. Po dokončení úlohy přenosu BITS odeberte úlohu z fronty voláním IBackgroundCopyJob::Complete.
  14. Nakonec uvolněte strukturu identity ověřování voláním funkce SspiFreeAuthIdentity.

Následující příklad kódu ukazuje, jak používat kódování ověřování SSPI s úlohami přenosu BITS.

#define SECURITY_WIN32
#define _SEC_WINNT_AUTH_TYPES

#include <windows.h>
#include <ntsecapi.h>
#include <bits.h>
#include <sspi.h>
#include <wincred.h>
#include <iostream>
#include <atlbase.h>
#include "CommonCode.h"

void PromptForCredentials(PWSTR pwTargetName)
{
    HRESULT hr;
    
    // If CoInitializeEx fails, the exception is unhandled and the program terminates
    CCoInitializer coInitializer(COINIT_APARTMENTTHREADED);
    
    CComPtr<IBackgroundCopyManager> pQueueMgr;
    CComPtr<IBackgroundCopyJob> pJob;
    CComPtr<IBackgroundCopyJob2> pJob2;

    PSEC_WINNT_AUTH_IDENTITY_OPAQUE pAuthIdentityEx2 = NULL;
    DWORD dwFlags = 0;
    BOOL fSave = FALSE;
    BOOL bReturn = TRUE;

    CREDUI_INFO creduiInfo = { 0 };
    creduiInfo.cbSize = sizeof(creduiInfo);
    // Change the message text and caption to the actual text for your dialog.
    creduiInfo.pszMessageText = pwTargetName;
    creduiInfo.pszCaptionText = L"SSPIPFC title for the dialog box";

    try {
        // Prompt for credentials from user using Negotiate security package.
        DWORD dwRet = SspiPromptForCredentials(
            pwTargetName,
            &creduiInfo,
            0,
            L"Negotiate", 
            NULL,
            &pAuthIdentityEx2,
            &fSave,
            dwFlags
            );

        if (SEC_E_OK != dwRet) 
        {
            // Prompt for credentials failed.
            throw MyException(dwRet, L"SspiPromptForCredentials");
        }

        if (NULL != pAuthIdentityEx2) 
        {
            GUID guidJob;
            BG_AUTH_CREDENTIALS authCreds;

            PCWSTR pwUserName = NULL;
            PCWSTR pwDomainName = NULL;
            PCWSTR pwPassword = NULL;

            // Encode credential structure as strings that can
            // be passed to a BITS job.
            SECURITY_STATUS secStatus = SspiEncodeAuthIdentityAsStrings(
                pAuthIdentityEx2,
                &pwUserName,
                &pwDomainName,
                &pwPassword
                );

            if(SEC_E_OK != secStatus) 
            {
                // Encode authentication identity as strings.
                throw MyException(secStatus, L"SspiEncodeAuthIdentityAsStrings");   
            }

            // Show the encoded user name and domain name.
            wprintf(
                L"User Name: %s\nDomain Name: %s",
                pwUserName,
                pwDomainName
                );

            //The impersonation level must be at least RPC_C_IMP_LEVEL_IMPERSONATE.
            HRESULT hr = CoInitializeSecurity(
                NULL,
                -1,
                NULL,
                NULL,
                RPC_C_AUTHN_LEVEL_CONNECT,
                RPC_C_IMP_LEVEL_IMPERSONATE,
                NULL,
                EOAC_DYNAMIC_CLOAKING,
                0
                );
            
            if (FAILED(hr))
            {
                throw MyException(hr, L"CoInitializeSecurity");
            }

            // Connect to BITS.
            hr = CoCreateInstance(__uuidof(BackgroundCopyManager), NULL,
                CLSCTX_LOCAL_SERVER,
                __uuidof(IBackgroundCopyManager),
                (void**) &pQueueMgr);

            if (FAILED(hr))
            {
                // Failed to connect.
                throw MyException(hr, L"CoCreateInstance");
            }

            // Create a job.
            hr = pQueueMgr->CreateJob(
                L"EncodeSample", 
                BG_JOB_TYPE_DOWNLOAD, 
                &guidJob, 
                &pJob
                );

            if(FAILED(hr))
            {   
                // Failed to create a BITS job.
                throw MyException(hr, L"CreateJob");
            }

            // Get IBackgroundCopyJob2 interface.
            hr = pJob->QueryInterface(__uuidof(IBackgroundCopyJob2), (void**)&pJob2);
            if (FAILED(hr)) 
            {
                // Failed to get a reference to the IBackgroundCopyJob2 interface.
                throw MyException(hr, L"QueryInterface(IBackgroundCopyJob2)");
            }

            // Create a BITS authentication structure from the encoded strings.
            authCreds.Target = BG_AUTH_TARGET_SERVER;
            authCreds.Scheme = BG_AUTH_SCHEME_NEGOTIATE;
            authCreds.Credentials.Basic.UserName = (LPWSTR)pwUserName;
            authCreds.Credentials.Basic.Password = (LPWSTR)pwPassword;

            // Set the credentials for the job.
            hr = pJob2->SetCredentials(&authCreds);
            if (FAILED(hr)) 
            {
                // Failed to set credentials.
                throw MyException(hr, L"SetCredentials");
            }

            // Modify the job's property values.
            // Add files to the job.
            // Activate (resume) the job in the transfer queue.

            // Remove the job from the transfer queue.
            hr = pJob->Complete();
            if (FAILED(hr)) 
            {
                // Failed to complete the job.
                throw MyException(hr, L"Complete");
            }
        }
    }
    catch(std::bad_alloc &)
    {
        wprintf(L"Memory allocation failed");
        if (pJob != NULL)
        {
            pJob->Cancel();
        }
    }
    catch(MyException &ex)
    {
        wprintf(L"Error %x occurred during operation", ex.Error);
        if (pJob != NULL)
        {
            pJob->Cancel();
        }
    }

    // Free the auth identity structure.
    if (NULL != pAuthIdentityEx2)
    {
        SspiFreeAuthIdentity(pAuthIdentityEx2);
        pAuthIdentityEx2 = NULL;
    }

    return;
}

void _cdecl _tmain(int argc, LPWSTR* argv)
{
    PromptForCredentials(L"Target");
}

SSPI

IBackgroundCopyManager

IBackgroundCopyJob

IBackgroundCopyJob2

Příklad : Běžné třídy

 

 

  • Last updated on