Microsoft Information Protection SDK - Implementazione di un delegato di autenticazione (C++)Microsoft Information Protection SDK - Implementing an authentication delegate (C++)

MIP SDK implementa un delegato di autenticazione per la gestione delle richieste di autenticazione e la risposta con un token.The MIP SDK does implement an authentication delegate for handling authentication challenges and responding with a token. Non implementa direttamente l'acquisizione del token.It does not itself implement token acquisition. Il processo di acquisizione di token è compito dello sviluppatore e viene eseguito estendendo la classe mip::AuthDelegate, in particolare la funzione membro AcquireOAuth2Token.The token acquisition process is up to the developer and is accomplished by extending the mip::AuthDelegate class, specifically the AcquireOAuth2Token member function.

Creazione di AuthDelegateImplBuilding AuthDelegateImpl

Per estendere la classe di base mip::AuthDelegate, viene creata una nuova classe denominata sample::auth::AuthDelegateImpl.To extend the base class mip::AuthDelegate, we create a new class called sample::auth::AuthDelegateImpl. Questa classe implementa la funzionalità AcquireOAuth2Token e configura il costruttore per accettare i parametri di autenticazione.This class implements the AcquireOAuth2Token functionality, and sets up the constructor to take in our authentication parameters.

auth_delegate_impl.hauth_delegate_impl.h

Per questo esempio, il costruttore predefinito accetta solo nome utente, password e ID applicazione dell'applicazione.For this example, the default constructor accepts just username, password, and the application's application ID. Queste informazioni verranno archiviate nelle variabili private mUserName, mPassword e mClientId.These will be stored in the private variables mUserName, mPassword, and mClientId.

È importante notare che informazioni come il provider di identità o l'URI della risorsa non sono necessarie per l'implementazione, almeno non nel costruttore AuthDelegateImpl.It's important to note that information such as the identity provider or resource URI aren't necessary to implement, at least not in the AuthDelegateImpl constructor. Queste informazioni vengono passate come parte di AcquireOAuth2Token nell'oggetto OAuth2Challenge.That information is passed as part of AcquireOAuth2Token in the OAuth2Challenge object. Questi dettagli verranno invece passati alla chiamata AcquireToken in AcquireOAuth2Token.Instead, we'll pass those details to the AcquireToken call in AcquireOAuth2Token.

//auth_delegate_impl.h
#include <string.h>
#include "mip/common_types.h"

namespace sample {
namespace auth {
class AuthDelegateImpl final : public mip::AuthDelegate { //extend mip::AuthDelegate base class
public:
  AuthDelegateImpl() = delete;

//constructor accepts username, password, and mip::ApplicationInfo.
  AuthDelegateImpl::AuthDelegateImpl(
    const mip::ApplicationInfo& applicationInfo,
    std::string& username,
    const std::string& password)
    : mApplicationInfo(applicationInfo),
      mUserName(username),
      mPassword(password) {
  }

  bool AcquireOAuth2Token(const mip::Identity& identity, const OAuth2Challenge& challenge, OAuth2Token& token) override;

  private:
    std::string mUserName;
    std::string mPassword;
    std::string mClientId;
    mip::ApplicationInfo mApplicationInfo;
};
}
}

auth_delegate_impl.cppauth_delegate_impl.cpp

AcquireOAuth2Token è la posizione in cui verrà effettuata la chiamata al provider OAuth2.AcquireOAuth2Token is where the call to the OAuth2 provider will be made. Nell'esempio di seguito sono presenti due chiamate a AcquireToken().In the example, below there are two calls to AcquireToken(). Nella pratica, verrebbe effettuata una sola chiamata.In practice, only one call would be made. Queste implementazioni verranno trattate nelle sezioni indicate in Passaggi successiviThese implementations will be covered in the sections provided under Next Steps

//auth_delegate_impl.cpp
#include "auth_delegate_impl.h"
#include <stdexcept>
#include "auth.h" //contains the auth class used later for token acquisition

using std::runtime_error;
using std::string;

namespace sample {
namespace auth {

AuthDelegateImpl::AuthDelegateImpl(
    const string& userName,
    const string& password,
    const string& clientId)
    : mApplicationInfo(applicationInfo),
    mUserName(userName),
    mPassword(password) {
}

//Here we could simply add our token acquisition code to AcquireOAuth2Token
//Instead, that code is implemented in auth.h/cpp to demonstrate calling an external library
bool AuthDelegateImpl::AcquireOAuth2Token(
    const mip::Identity& /*identity*/, //This won't be used
    const OAuth2Challenge& challenge,
    const OAuth2Token& token) {

      //sample::auth::AcquireToken is the code where the token acquisition routine is implemented.
      //AcquireToken() returns a string that contains the OAuth2 token.

      //Simple example for getting hard coded token. Comment out if not used.
      string accessToken = sample::auth::AcquireToken();

      //Practical example for calling external OAuth2 library with provided authentication details.
      string accessToken = sample::auth::AcquireToken(mUserName, mPassword, mApplicationInfo.applicationId, challenge.GetAuthority(), challenge.GetResource());

      //set the passed in OAuth2Token value to the access token acquired by our provider
      token.SetAccessToken(accessToken);
      return true;
    }
}
}

Passaggi successiviNext Steps

Per completare l'implementazione dell'autenticazione, è necessario sviluppare il codice dietro la funzione AcquireToken().To complete the authentication implementation, it's necessary to build the code behind the AcquireToken() function. Gli esempi seguenti illustrano alcuni modi per acquisire il token.The examples below discuss a few ways to acquire the token.