Compartir a través de

Inicio rápido para volver a publicar el SDK de archivo (C++)

  • Artículo

Información general

Para obtener información general sobre este escenario y dónde se puede usar, vea Repetición de la publicación en el SDK de MIP.

Requisitos previos

Si todavía no lo ha hecho, complete los siguientes requisitos previos antes de continuar:

Incorporación de lógica a la clase de observador FileHandler

Para poder descifrar un archivo protegido con el método GetDecryptedTemporaryFileAsync() expuesto por mip::FileHandler, las devoluciones de llamada del método asincrónico para el éxito y el error se deben definir como se indica a continuación.

  1. Abra la solución de Visual Studio que ha creado en el artículo anterior "Inicio rápido: Establecimiento u obtención de etiquetas de confidencialidad (C++)".

  2. Con el Explorador de soluciones, abra el archivo filehandler_observer.h del proyecto. Hacia la parte final de la definición FileHandler, antes de };, agregue las líneas siguientes para la declaración de método.

        void OnGetDecryptedTemporaryFileSuccess(const std::string& decryptedFilePath, const std::shared_ptr<void>& context) override;
    void OnGetDecryptedTemporaryFileFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;

  3. Con el Explorador de soluciones, abra el archivo filehandler_observer.cpp del proyecto. Hacia la parte final del archivo, agregue las líneas siguientes para las definiciones de método.

    
    void FileHandlerObserver::OnGetDecryptedTemporaryFileSuccess(const std::string& decryptedFilePath, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::string>>(context);
    promise->set_value(decryptedFilePath);
    }

    void FileHandlerObserver::OnGetDecryptedTemporaryFileFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) {
    auto promise = std::static_pointer_cast<std::promise<std::string>>(context);
    promise->set_exception(error);
    }

Incorporación de lógica para editar y volver a publicar un archivo protegido

  1. Desde el Explorador de soluciones, abra el archivo .cpp del proyecto que contiene la implementación del método main(). De manera predeterminada, tiene el mismo nombre que el proyecto que lo contiene, que especificó al crear el proyecto.

  2. Hacia la parte final del cuerpo de main(), debajo de system("pause") y encima de return 0; (donde lo ha dejado en el inicio rápido anterior), inserte el código siguiente:

//Originally protected file's path.
std::string protectedFilePath = "<protected-file-path>";

// Create file handler for the file
auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
auto handlerFuture = handlerPromise->get_future();
engine->CreateFileHandlerAsync(protectedFilePath, 
                                protectedFilePath, 
                                true, 
                                std::make_shared<FileHandlerObserver>(), 
                                handlerPromise);
auto protectedFileHandler = handlerFuture.get();

// retieve and store protection handler from file
auto protectionHandler = protectedFileHandler->GetProtection();

//Check if the user has the 'Edit' right to the file and if so decrypt the file.
if (protectionHandler->AccessCheck("Edit")) {

    // Decrypt file to temp path using the same file handler
    auto tempPromise = std::make_shared<std::promise<string>>();
    auto tempFuture = tempPromise->get_future();
    protectedFileHandler->GetDecryptedTemporaryFileAsync(tempPromise);
    auto tempPath = tempFuture.get();

    /// Write code here to perform further operations for edit ///

    /// Follow steps below for re-protecting the edited file ///

    // Create a new file handler using the temporary file path.
    auto reprotectPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
    auto reprotectFuture = reprotectPromise->get_future();
    engine->CreateFileHandlerAsync(tempPath, 
                                    tempPath, 
                                    true, 
                                    std::make_shared<FileHandlerObserver>(), 
                                    reprotectPromise);
    auto republishHandler = reprotectFuture.get();

    // Set protection using the ProtectionHandler from the original consumption operation.
    republishHandler->SetProtection(protectionHandler);
    std::string reprotectedFilePath = "<protected-file-path>";

    // Commit changes
    auto republishPromise = std::make_shared<std::promise<bool>>();
    auto republishFuture = republishPromise->get_future();
    republishHandler->CommitAsync(reprotectedFilePath, republishPromise);

    // Validate republishing
    cout << "Protected File: " + protectedFilePath<<endl;
    cout << "Protected Label ID: " + protectedFileHandler->GetLabel()->GetLabel()->GetId() << endl;
    cout << "Protection Owner: " + protectedFileHandler->GetProtection()->GetOwner() << endl<<endl;

    cout << "Republished File: " + reprotectedFilePath<<endl;
    cout << "Republished Label ID: " + republishHandler->GetLabel()->GetLabel()->GetId() << endl;
    cout << "Republished Owner: " + republishHandler->GetProtection()->GetOwner() << endl;
}

  1. Hacia la parte final de Main(), busque el bloque de cierre de la aplicación creado en el inicio rápido anterior y agregue la líneas de controlador siguientes para liberar recursos.

        protectedFileHandler = nullptr;
    protectionHandler = nullptr;

  2. Reemplace los valores de marcador de posición del código fuente por los valores siguientes:

    Marcador Valor
    <protected-file-path> Archivo protegido del inicio rápido anterior.
    <reprotected-file-path> Ruta del archivo de salida para que el archivo modificado se vuelva a publicar.

Compilar y probar la aplicación

Compile y pruebe la aplicación cliente.

  1. Presione CTRL-MAYÚS-B (Compilar solución) para compilar la aplicación cliente. Si no hay errores de compilación, presione F5 (Iniciar depuración) para ejecutar la aplicación.

  2. Si el proyecto se compila y se ejecuta correctamente, la aplicación solicita un token de acceso cada vez que el SDK llama al método AcquireOAuth2Token(). Como hizo anteriormente en la guía de inicio rápido "Definición u obtención de etiquetas de confidencialidad", ejecute el script de PowerShell para adquirir el token cada vez, con los valores proporcionados para $authority y $resourceUrl.

  Sensitivity labels for your organization:
  Non-Business : 87ba5c36-17cf-14793-bbc2-bd5b3a9f95cz
  Public : 83867195-f2b8-2ac2-b0b6-6bb73cb33afz
  General : f42a3342-8706-4288-bd31-ebb85995028z
  Confidential : 074e457c-5848-4542-9a6f-34a182080e7z
  Highly Confidential : f55c2dea-db0f-47cd-8520-a52e1590fb6z
  Press any key to continue . . .

  Applying Label ID 074e457c-5848-4542-9a6f-34a182080e7z to C:\Test\Test.docx
  Committing changes
  
  Label committed to file: C:\Test\Test_labeled.docx
  Press any key to continue . . .

  Run the PowerShell script to generate an access token using the following values, then copy/paste it below:
  Set $authority to: https://login.windows.net/37f4583d-9985-4e7f-a1ab-71afd8b55ba0
  Set $resourceUrl to: https://aadrm.com
  Sign in with user account: user1@tenant.onmicrosoft.com
  Enter access token: <paste-access-token-here>
  Press any key to continue . . .

  Getting the label committed to file: C:\Test\Test_labeled.docx
  Name: Confidential
  Id: 074e457c-5848-4542-9a6f-34a182080e7z
  Press any key to continue . . .
  Protected File: C:\Test\Test_labeled.docx
  Protected Label ID: 074e457c-5848-4542-9a6f-34a182080e7z
  Protection Owner: user1@tenant.onmicrosoft.com

  Republished File: c:\Test\Test_republished.docx
  Republished Label ID: 074e457c-5848-4542-9a6f-34a182080e7z
  Republished Owner: user1@tenant.onmicrosoft.com

  Press any key to close this window . . .