Início Rápido: Inicialização do aplicativo cliente (C#)

Este guia de início rápido mostra como implementar o padrão de inicialização de cliente usado pelo wrapper .NET do SDK do MIP em tempo de execução.

Observação

Qualquer aplicativo cliente que utiliza os SDKs de Arquivo, Política ou Proteção do wrapper .NET do MIP requer seguir as etapas descritas neste guia de início rápido. Embora este início rápido demonstre o uso dos SDKs de Arquivo, esse mesmo padrão se aplica aos clientes que usam os SDKs de Política e Proteção. Conclua os inícios rápidos futuros em série, pois cada um deles se baseia no anterior, sendo este o primeiro. Esse código destina-se a demonstrar como começar a usar o SDK do MIP e não se destina ao uso de produção.

Pré-requisitos

Caso ainda não tenha feito isso, certifique-se de:

Criar uma solução e um projeto do Visual Studio

Primeiro, crie e configure a solução e o projeto iniciais do Visual Studio, nos quais os outros guias de início rápido se baseiam.

  1. Abra o Visual Studio 2022 ou posterior, selecione o menu Arquivo , Novo, Projeto. Na caixa de diálogo Novo Projeto :

    • No painel esquerdo, em Instalado, Visual C#, selecione Área de Trabalho do Windows.

    • No painel central, selecione Aplicativo de Console (destinado ao .NET 8 ou posterior).

    • No painel inferior, atualize o nome do projeto, o local e o nome da solução que contém adequadamente.

    • Quando terminar, clique no botão OK no canto inferior direito.

      Criação da solução do Visual Studio.

  2. Adicione o pacote NuGet para o SDK de Arquivo MIP ao seu projeto:

    • No Gerenciador de Soluções, clique com o botão direito do mouse no nó do projeto (diretamente no nó superior/solução) e selecione Gerenciar pacotes NuGet...:
    • Quando a guia Gerenciador de Pacotes NuGet é aberta na área de guias Grupo do Editor:
      • Selecione Procurar.
      • Insira "Microsoft.InformationProtection" na caixa de pesquisa.
      • Selecione o pacote "Microsoft.InformationProtection.File".
      • Clique em "Instalar" e, em seguida, clique em "OK" quando a caixa de diálogo de confirmação Visualizar alterações for exibida.

  3. Repita as etapas acima para adicionar o pacote MIP File SDK, mas em vez disso adicione "Microsoft.Identity.Client" ao aplicativo.

Implementar um delegado de autenticação

O SDK do MIP implementa a autenticação usando a extensibilidade de classe, que fornece um mecanismo para compartilhar o trabalho de autenticação com o aplicativo cliente. O cliente deve adquirir um token de acesso OAuth2 adequado e fornecê-lo ao SDK do MIP em runtime.

Agora, crie uma implementação para um delegado de autenticação estendendo a interface do Microsoft.InformationProtection.IAuthDelegate SDK e substituindo ou implementando a IAuthDelegate.AcquireToken() função virtual. Os objetos FileProfile e FileEngine instanciam e usam o delegado de autenticação posteriormente.

  1. Clique com o botão direito do mouse no nome do projeto no Visual Studio e selecione Adicionar então Classe.

  2. Insira "AuthDelegateImplementation" no campo Nome . Clique em Adicionar.

  3. Adicione instruções de uso para a MSAL (Biblioteca de Autenticação da Microsoft) e a biblioteca MIP:

    using Microsoft.InformationProtection;
using Microsoft.Identity.Client;

  4. Defina AuthDelegateImplementation para herdar Microsoft.InformationProtection.IAuthDelegate e implemente uma variável privada do tipo Microsoft.InformationProtection.ApplicationInfo e um construtor que aceite o mesmo tipo.

    public class AuthDelegateImplementation : IAuthDelegate
{
   private ApplicationInfo _appInfo;
   // Microsoft Authentication Library IPublicClientApplication
   private IPublicClientApplication _app;
   public AuthDelegateImplementation(ApplicationInfo appInfo)
   {
       _appInfo = appInfo;
   }

}

    O ApplicationInfo objeto contém três propriedades. A AuthDelegateImplementation classe usa _appInfo.ApplicationId para fornecer a ID do cliente para a biblioteca de autenticação. ApplicationName e ApplicationVersion aparecem nos relatórios de auditoria do Microsoft Purview.

  5. Adicione o método public string AcquireToken(). Esse método deve aceitar Microsoft.InformationProtection.Identity e três cadeias de caracteres: URL de autoridade, URI de recurso e declarações, se necessário. A API passa essas variáveis de cadeia de caracteres para a biblioteca de autenticação e você não deve manipulá-las. Insira o GUID do locatário no portal do Azure referente ao seu locatário. A edição de cadeias de caracteres diferentes do GUID do locatário pode resultar em uma falha na autenticação.

    public string AcquireToken(Identity identity, string authority, string resource, string claims)
{
   var authorityUri = new Uri(authority);
   authority = String.Format("https://{0}/{1}", authorityUri.Host, "<Tenant-GUID>");

   _app = PublicClientApplicationBuilder.Create(_appInfo.ApplicationId).WithAuthority(authority).WithDefaultRedirectUri().Build();
   var accounts = (_app.GetAccountsAsync()).GetAwaiter().GetResult();

   // Append .default to the resource passed in to AcquireToken().
   string[] scopes = new string[] { resource[resource.Length - 1].Equals('/') ? $"{resource}.default" : $"{resource}/.default" };
   var result = _app.AcquireTokenInteractive(scopes).WithAccount(accounts.FirstOrDefault()).WithPrompt(Prompt.SelectAccount)
              .ExecuteAsync().ConfigureAwait(false).GetAwaiter().GetResult();

   return result.AccessToken;
}

Agora, crie uma implementação para um delegado de consentimento estendendo a interface do Microsoft.InformationProtection.IConsentDelegate SDK e substituindo ou implementando GetUserConsent(). O perfil File e os objetos do File engine instanciam e usam o delegado de consentimento mais tarde. O delegado de consentimento recebe o endereço do serviço que o usuário deve consentir em usar no url parâmetro. O delegado geralmente deve fornecer um fluxo que permita que o usuário aceite ou rejeite o consentimento para acessar o serviço. Para este início rápido, codifique Consent.Accept.

  1. Usando o mesmo recurso "Adicionar Classe" do Visual Studio que usamos anteriormente, adicione outra classe ao seu projeto. Desta vez, insira "ConsentDelegateImplementation" no campo Nome da Classe .

  2. Agora atualize ConsentDelegateImpl.cs para implementar sua nova classe de delegado de consentimento. Adicione a instrução using para Microsoft.InformationProtection e defina a classe para herdar IConsentDelegate.

    class ConsentDelegateImplementation : IConsentDelegate
{
     public Consent GetUserConsent(string url)
     {
          return Consent.Accept;
     }
}

  3. Opcionalmente, tente criar a solução para garantir que ela seja compilada sem erros.

Inicializar o wrapper gerenciado do SDK da PIM

  1. No Gerenciador de Soluções, abra o arquivo .cs em seu projeto que contém a implementação do Main() método. Ele usa como padrão o mesmo nome do projeto que o contém, que você especificou durante a criação do projeto.

  2. Remova a implementação gerada de main().

  3. O wrapper gerenciado inclui uma classe estática, Microsoft.InformationProtection.MIP, usada para inicialização, criação de um MipContext, carregamento de perfis e liberação de recursos. Para inicializar o wrapper para operações no SDK de Arquivo, chame MIP.Initialize(), passando MipComponent.File para carregar as bibliotecas necessárias para as operações com arquivos.

  4. No Main()Program.cs adicione o seguinte, substituindo <application-id> pelo ID do Registro de Aplicativo do Microsoft Entra criado anteriormente.

using System;
using System.Threading.Tasks;
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.Exceptions;
using Microsoft.InformationProtection.File;
using Microsoft.InformationProtection.Protection;

namespace mip_sdk_dotnet_quickstart
{
    class Program
    {
        private const string clientId = "<application-id>";
        private const string appName = "<friendly-name>";

        static void Main(string[] args)
        {
            //Initialize Wrapper for File SDK operations
            MIP.Initialize(MipComponent.File);
            
        }
    }
}

Construir um Perfil e um Mecanismo de arquivo

Como mencionado, os clientes do SDK que usam APIs de MIP exigem objetos de perfil e de mecanismo. Conclua a parte de codificação deste início rápido adicionando código para carregar as DLLs nativas e, em seguida, instanciar o perfil e os objetos do mecanismo.

using System;
using System.Threading.Tasks;
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.File;

namespace mip_sdk_dotnet_quickstart
{
  class Program
  {
       private const string clientId = "<application-id>";
       private const string appName = "<friendly-name>";

       static void Main(string[] args)
       {
            // Initialize Wrapper for File SDK operations.
            MIP.Initialize(MipComponent.File);

            // Create ApplicationInfo, setting the clientID from Microsoft Entra App Registration as the ApplicationId.
            ApplicationInfo appInfo = new ApplicationInfo()
            {
                 ApplicationId = clientId,
                 ApplicationName = appName,
                 ApplicationVersion = "1.0.0"
            };

            // Instantiate the AuthDelegateImpl object, passing in AppInfo.
            AuthDelegateImplementation authDelegate = new AuthDelegateImplementation(appInfo);

            // Create MipConfiguration Object
            MipConfiguration mipConfiguration = new MipConfiguration(appInfo, "mip_data", LogLevel.Trace, false);

            // Create MipContext using Configuration
            MipContext mipContext = MIP.CreateMipContext(mipConfiguration);

            // Initialize and instantiate the File Profile.
            // Create the FileProfileSettings object.
            // Initialize file profile settings to create/use local state.
            var profileSettings = new FileProfileSettings(mipContext,
                                     CacheStorageType.OnDiskEncrypted,
                                     new ConsentDelegateImplementation());

            // Load the Profile async and wait for the result.
            var fileProfile = Task.Run(async () => await MIP.LoadFileProfileAsync(profileSettings)).Result;

            // Create a FileEngineSettings object, then use that to add an engine to the profile.
            // This pattern sets the engine ID to user1@tenant.com, then sets the identity used to create the engine.
            var engineSettings = new FileEngineSettings("user1@tenant.com", authDelegate, "", "en-US");
            engineSettings.Identity = new Identity("user1@tenant.com");

            var fileEngine = Task.Run(async () => await fileProfile.AddEngineAsync(engineSettings)).Result;

            // Application Shutdown
            // handler = null; // This will be used in later quick starts.
            fileEngine = null;
            fileProfile = null;
            mipContext.ShutDown();
            mipContext = null;
       }
  }
}

  1. Substitua os valores dos marcadores de posição no código-fonte que você colou pelos seguintes valores:

    Espaço reservado Valor Exemplo
    <application-id> O ID do aplicativo do Microsoft Entra atribuído ao aplicativo registrado em "Instalação e configuração do SDK do MIP" (2 instâncias). 00001111-aaaa-2222-bbbb-3333cccc4444
    <nome amigável> Um nome amigável definido pelo usuário para seu aplicativo. Inicialização do Aplicativo
    <GUID do locatário> ID do tenant do seu Microsoft Entra. TenantID

  2. Agora, faça um build final do aplicativo e resolva quaisquer erros. Seu código deve ser compilado com sucesso.

Próximas Etapas 

Agora que o código de inicialização está concluído, você está pronto para o próximo início rápido, no qual você começa a experimentar os SDKs de Arquivo MIP.

Listar etiquetas de sensibilidade

  • Last updated on