Aquisição de um token de acesso (Python)

Este exemplo demonstra como chamar um script Python externo para obter um token OAuth2. Um token de acesso OAuth2 válido é exigido pela implementação do delegado de autenticação.

Pré-requisitos

Para executar o exemplo:

• Instale o Python 3.10 ou mais recente.
• Implemente utils.h/cpp em seu projeto.
• Auth.py deve ser adicionados ao seu projeto e existir no mesmo diretório que os binários na compilação.
• Conclua a instalação e configuração do SDK do Microsoft Information Protection (MIP). Entre outras tarefas, você registra seu aplicativo cliente em seu locatário do Microsoft Entra. O Microsoft Entra ID fornece uma ID de aplicativo, também conhecida como ID do cliente, que é usada em sua lógica de aquisição de token.

Esse código não se destina ao uso em produção. Ele só pode ser usado para desenvolvimento e compreensão dos conceitos de autenticação. A amostra é multiplataforma.

sample::auth::AcquireToken()

No exemplo de autenticação simples, demonstramos uma função AcquireToken() simples que não recebeu parâmetros e retornou um valor de token embutido em código. Neste exemplo, sobrecarregamos AcquireToken() para aceitar parâmetros de autenticação e chamamos um script Python externo para retornar o token.

auth.h

Em auth.h, AcquireToken() está sobrecarregado e a função sobrecarregada e os parâmetros atualizados são os seguintes:

//auth.h
#include <string>

namespace sample {
  namespace auth {
    std::string AcquireToken(
        const std::string& userName, //A string value containing the user's UPN.
        const std::string& password, //The user's password in plaintext
        const std::string& clientId, //The Azure AD client ID (also known as Application ID) of your application.
        const std::string& resource, //The resource URL for which an OAuth2 token is required. Provided by challenge object.
        const std::string& authority); //The authentication authority endpoint. Provided by challenge object.
    }
}

Os três primeiros parâmetros são fornecidos pela entrada do usuário ou codificados em seu aplicativo. Os dois últimos parâmetros são fornecidos pelo SDK ao delegado de autenticação.

auth.cpp

Em auth.cpp, adicionamos a definição de função sobrecarregada e, em seguida, definimos o código necessário para chamar o script Python. A função aceita todos os parâmetros fornecidos e os transmite ao script Python. O script executa e retorna o token no formato de sequência.

#include "auth.h"
#include "utils.h"

#include <fstream>
#include <functional>
#include <memory>
#include <string>

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

namespace sample {
    namespace auth {

    //This function implements token acquisition in the application by calling an external Python script.
    //The Python script requires username, password, clientId, resource, and authority.
    //Username, Password, and ClientId are provided by the user/developer
    //Resource and Authority are provided as part of the OAuth2Challenge object that is passed in by the SDK to the AuthDelegate.
    string AcquireToken(
        const string& userName,
        const string& password,
        const string& clientId,
        const string& resource,
        const string& authority) {

    string cmd = "python";
    if (sample::FileExists("auth.py"))
        cmd += " auth.py -u ";

    else
        throw runtime_error("Unable to find auth script.");

    cmd += userName;
    cmd += " -p ";
    cmd += password;
    cmd += " -a ";
    cmd += authority;
    cmd += " -r ";
    cmd += resource;
    cmd += " -c ";
    // Replace <application-id> with the Application ID provided during your Azure AD application registration.
    cmd += (!clientId.empty() ? clientId : "<application-id>");

    string result = sample::Execute(cmd.c_str());
    if (result.empty())
        throw runtime_error("Failed to acquire token. Ensure Python is installed correctly.");

    return result;
    }
    }
}

Script em Python

Esse script adquire tokens de autenticação diretamente por meio da Microsoft Authentication Library (MSAL) para Python. Esse código é incluído apenas como um meio de adquirir tokens de autenticação para uso pelos aplicativos de exemplo e não se destina ao uso em produção. O script funciona apenas em locatários que oferecem suporte à autenticação de nome de usuário/senha antiga simples. Não há suporte para MFA ou autenticação baseada em certificado por meio desse script.

pip install msal
pip3 install msal

import getopt
import sys
import json
import re
from msal import PublicClientApplication

def printUsage():
  print('auth.py -u <username> -p <password> -a <authority> -r <resource> -c <clientId>')

def main(argv):
  try:
    options, args = getopt.getopt(argv, 'hu:p:a:r:c:')
  except getopt.GetoptError:
    printUsage()
    sys.exit(-1)

  username = ''
  password = ''
  authority = ''
  resource = ''

  clientId = ''
    
  for option, arg in options:
    if option == '-h':
      printUsage()
      sys.exit()
    elif option == '-u':
      username = arg
    elif option == '-p':
      password = arg
    elif option == '-a':
      authority = arg
    elif option == '-r':
      resource = arg
    elif option == '-c':
      clientId = arg

  if username == '' or password == '' or authority == '' or resource == '' or clientId == '':
    printUsage()
    sys.exit(-1)

  # ONLY FOR DEMO PURPOSES AND MSAL FOR PYTHON
  # This shouldn't be required when using proper auth flows in production.  
  if authority.find('common') > 1:
    authority = authority.split('/common')[0] + "/organizations"
   
  app = PublicClientApplication(client_id=clientId, authority=authority)  
  
  result = None  

  if resource.endswith('/'):
    resource += ".default"    
  else:
    resource += "/.default"
  
  # *DO NOT* use username/password authentication in production system.
  # Instead, consider auth code flow and using a browser to fetch the token.
  result = app.acquire_token_by_username_password(username=username, password=password, scopes=[resource])  
  print(result['access_token'])

if __name__ == '__main__':  
  main(sys.argv[1:])

Atualizar AcquireOAuth2Token

Finalmente, atualize a função AcquireOAuth2Token em AuthDelegateImpl para chamar a função AcquireToken sobrecarregada. As URLs de recurso e autoridade são obtidas pela leitura de challenge.GetResource() e de challenge.GetAuthority(). O OAuth2Challenge é transmitido ao delegado de autenticação quando o mecanismo é adicionado. Esse trabalho é feito pelo SDK e não requer trabalho extra por parte do desenvolvedor.

bool AuthDelegateImpl::AcquireOAuth2Token(
    const mip::Identity& /*identity*/,
    const OAuth2Challenge& challenge,
    OAuth2Token& token) {

    //call our AcquireToken function, passing in username, password, clientId, and getting the resource/authority from the OAuth2Challenge object
    string accessToken = sample::auth::AcquireToken(mUserName, mPassword, mClientId, challenge.GetResource(), challenge.GetAuthority());
    token.SetAccessToken(accessToken);
    return true;
}

Quando o é adicionado, o SDK chama a função 'AcquireOAuth2Token, passando o desafio, executando o script Python, recebendo um token e, em seguida, apresentando o engine token ao serviço.