Microsoft Information Protection SDK

https://learn.microsoft.com/en-us/information-protection/develop
Admin
The Microsoft Information Protection SDK enables developers to integrate data classification,...
Tokens:117,198
Snippets:743
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install MSAL for Python with pip

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-authentication-acquire-token-py

Before running the sample, install MSAL for Python using either pip or pip3.

```bash
pip install msal
```

```bash
pip3 install msal
```

--------------------------------

### Example console output showing protection templates

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-protection-list-templates-cpp

This is an example of the console output after pasting the access token. It shows the list of protection templates with their names and IDs, followed by the process exit code and a prompt to close the console.

```text
*** Template List:
Name: Confidential \ All Employees : a74f5027-f3e3-4c55-abcd-74c2ee41b607
Name: Highly Confidential \ All Employees : bb7ed207-046a-4caf-9826-647cff56b990
Name: Confidential : 174bc02a-6e22-4cf2-9309-cb3d47142b05
Name: Contoso Employees Only : 667466bf-a01b-4b0a-8bbf-a79a3d96f720

C:\MIP Sample Apps\ProtectionQS\Debug\ProtectionQS.exe (process 8252) exited with code 0.
To automatically close the console when debugging stops, enable Tools->Options->Debugging->Automatically close the console when debugging stops.

Press any key to continue . . .
```

--------------------------------

### Example output of sensitivity labels

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-policy-list-labels-csharp

Example output showing the sensitivity labels and their child labels with placeholder IDs.

```text
Sensitivity labels for your organization:
Public : <label-id>
General : <label-id>
->  Anyone (unrestricted) : <label-id>
Confidential : <label-id>
->  All Employees : <label-id>
->  Recipients Only : <label-id>
Highly Confidential : <label-id>
->  All Employees : <label-id>
->  Recipients Only : <label-id>
```

--------------------------------

### Install Microsoft.InformationProtection.File package

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-summary-csharp

Run this command in the Package Manager Console in Visual Studio 2022 or later to install the Microsoft Information Protection .NET Wrapper. No extra packages are needed; the package includes all third-party libraries and copies them to the output folder on build.

```powershell
install-package Microsoft.InformationProtection.File
```

--------------------------------

### Create FileEngineSettings

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-profile-engine-cpp

Example of creating a FileEngineSettings object for a FileEngine.

```APIDOC
## Create FileEngineSettings

### Description
Creates a FileEngineSettings object used to create a FileEngine.

### Code Example
```cpp
// Create the FileEngineSettings object
FileEngine::Settings engineSettings(mip::Identity(mUsername), // This will be the engine ID. UPN, email address, or other unique user identifiers are recommended. 
													  mAuthDelegate,            // authDelegate implementation 
													  "",                       // ClientData
													  "en-US",                  // Client Locale
                                    false);                   // Load Sensitive Information Types
```
```

--------------------------------

### Install MIP SDK NuGet packages

Source: https://learn.microsoft.com/en-us/information-protection/develop/setup-configure-mip

Use the NuGet Package Manager Console to install the MIP SDK packages for File, Policy, and Protection APIs.

```powershell
Install-Package Microsoft.InformationProtection.File
Install-Package Microsoft.InformationProtection.Policy
Install-Package Microsoft.InformationProtection.Protection
```

--------------------------------

### Example output: MetadataAction add and remove lists

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-handler-policy-computeactions-cpp

This output shows the result of ComputeActions() for the label downgrade example. It lists the metadata entries to add (for the new label) and to remove (for the old label). The actual actions depend on the input labels and label configuration.

```text
Add: MSIP_Label_d48d0e60-c766-40d6-96d3-53b2857fe775_Enabled : true
Add: MSIP_Label_d48d0e60-c766-40d6-96d3-53b2857fe775_SetDate : 2018-10-23T23:59:41-0800
Add: MSIP_Label_d48d0e60-c766-40d6-96d3-53b2857fe775_Method : Standard
Add: MSIP_Label_d48d0e60-c766-40d6-96d3-53b2857fe775_Name : General
Add: MSIP_Label_d48d0e60-c766-40d6-96d3-53b2857fe775_SiteId : 94f6984e-8d31-4794-bdeb-3ac89ad2b660
Add: MSIP_Label_d48d0e60-c766-40d6-96d3-53b2857fe775_ActionId : 447a996b-28ea-482c-b0b5-000075bd4bb3
Add: MSIP_Label_d48d0e60-c766-40d6-96d3-53b2857fe775_ContentBits : 7
Remove: MSIP_Label_d7b93a40-4df3-47e4-b2fd-7862fc6b095c_Name
Remove: MSIP_Label_d7b93a40-4df3-47e4-b2fd-7862fc6b095c_Enabled
Remove: MSIP_Label_d7b93a40-4df3-47e4-b2fd-7862fc6b095c_SiteId
Remove: MSIP_Label_d7b93a40-4df3-47e4-b2fd-7862fc6b095c_SetDate
Remove: MSIP_Label_d7b93a40-4df3-47e4-b2fd-7862fc6b095c_Method
Remove: MSIP_Label_d7b93a40-4df3-47e4-b2fd-7862fc6b095c_ContentBits
Remove: MSIP_Label_d7b93a40-4df3-47e4-b2fd-7862fc6b095c_ActionId
```

--------------------------------

### C# (.NET) DeleteStoredData examples

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-delete-stored-data

C# (.NET) examples for the ProtectionEngine.DeleteStoredData() method. The first call deletes only expired cached data. The second call with 'deleteAllData: true' deletes all cached data. The third call deletes cached data older than 30 days using a DateTime.UtcNow time point.

```csharp
// Delete only expired cached data
protectionEngine.DeleteStoredData();

// Delete all cached data
protectionEngine.DeleteStoredData(deleteAllData: true);

// Delete cached data older than 30 days
var thirtyDaysAgo = DateTime.UtcNow.AddDays(-30);
protectionEngine.DeleteStoredData(thirtyDaysAgo);
```

--------------------------------

### Install MSAL.PS PowerShell module

Source: https://learn.microsoft.com/en-us/information-protection/develop/setup-configure-mip

Run this cmdlet in an elevated PowerShell session to install the MSAL.PS module. The output shows a prompt about installing from an untrusted repository; respond with 'A' to proceed.

```powershell
PS C:\WINDOWS\system32> Install-Module -Name MSAL.PS

Untrusted repository
You are installing the modules from an untrusted repository. If you trust this repository, change its
InstallationPolicy value by running the Set-PSRepository cmdlet. Are you sure you want to install the modules from
'PSGallery'?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "N"): A

PS C:\WINDOWS\system32>
```

--------------------------------

### Initialize Policy profile and engine in Program.cs

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-policy-app-initialization-csharp

Update Program.cs to create MipContext, load a PolicyProfile, and add a PolicyEngine. Requires an AuthDelegateImplementation class and a valid application ID and user email. The application should initialize and connect to the Policy service.

```csharp
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.Policy;

// Application info for Microsoft Entra app registration
ApplicationInfo appInfo = new ApplicationInfo()
{
    ApplicationId = "<application-id>",
    ApplicationName = "MIP SDK Policy Quickstart",
    ApplicationVersion = "1.0"
};

// Create MipConfiguration and MipContext
var mipConfiguration = new MipConfiguration(appInfo, "mip_data", LogLevel.Trace, false, CacheStorageType.OnDiskEncrypted);
var mipContext = MIP.CreateMipContext(mipConfiguration);

// Create auth and consent delegates
var authDelegate = new AuthDelegateImplementation(appInfo);
var consentDelegate = new ConsentDelegateImplementation();

// Create PolicyProfile
var profileSettings = new PolicyProfileSettings(mipContext, CacheStorageType.OnDiskEncrypted);
var profile = MIP.LoadPolicyProfileAsync(profileSettings).GetAwaiter().GetResult();

// Create PolicyEngine
var engineSettings = new PolicyEngineSettings(
    id: "<user@contoso.com>",
    authDelegate: authDelegate,
    clientData: "",
    locale: "en-US")
{
    Identity = new Identity("<user@contoso.com>")
};

var engine = profile.AddEngineAsync(engineSettings).GetAwaiter().GetResult();

Console.WriteLine("Policy engine loaded successfully.");
```

--------------------------------

### Construct a Protection profile and engine in C++

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-protection-app-initialization-cpp

This snippet initializes the MIP context, creates a ProtectionProfile and ProtectionEngine, and loads them asynchronously. It includes error handling for profile and engine loading, and demonstrates proper shutdown by nulling out objects and calling ShutDown(). Replace all placeholder values (e.g., <application-id>, <application-name>, <application-version>, <engine-account>) with your own values.

```cpp
#include "mip/mip_context.h"  
#include "auth_delegate.h"
#include "consent_delegate.h"
#include "profile_observer.h"
#include"engine_observer.h"

using std::promise;
using std::future;
using std::make_shared;
using std::shared_ptr;
using std::string;
using std::cout;
using mip::ApplicationInfo;
using mip::ProtectionProfile;
using mip::ProtectionEngine;

int main(){

  // Construct/initialize objects required by the application's profile object
  // ApplicationInfo object (App ID, name, version)
  ApplicationInfo appInfo{"<application-id>",                    
                          "<application-name>",
                          "<application-version>"};

  std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(appInfo,
				                                                                               "mip_data",
                                                                                      			         mip::LogLevel::Trace,
                                                                                                     false,
                                                                                                     mip::CacheStorageType::OnDisk);

  std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

  auto profileObserver = make_shared<ProtectionProfileObserver>(); // Observer object
  auto authDelegateImpl = make_shared<AuthDelegateImpl>("<application-id>"); // Authentication delegate object (App ID)
  auto consentDelegateImpl = make_shared<ConsentDelegateImpl>(); // Consent delegate object

  // Construct/initialize profile object
  ProtectionProfile::Settings profileSettings(
    mMipContext,
    mip::CacheStorageType::OnDisk,      
    consentDelegateImpl,
    profileObserver);

  // Set up promise/future connection for async profile operations; load profile asynchronously
  auto profilePromise = make_shared<promise<shared_ptr<ProtectionProfile>>>();
  auto profileFuture = profilePromise->get_future();
  try
  {
    mip::ProtectionProfile::LoadAsync(profileSettings, profilePromise);
  }
  catch (const std::exception& e)
  {
    cout << "An exception occurred... are the Settings and ApplicationInfo objects populated correctly?\n\n"
          << e.what() << "'\n";
    system("pause");
    return 1;
  }

  auto profile = profileFuture.get();

  // Construct/initialize engine object
  ProtectionEngine::Settings engineSettings(       
     mip::Identity("<engine-account>"),         // Engine identity (account used for authentication)
     authDelegateImpl,                          // Reference to mip::AuthDelegate implementation
     "",                                        // ClientData field
     "en-US");                                  // Locale (default = en-US)

  // Set the engineId so it can be cached and reused. 
  engineSettings.SetEngineId("<engine-account>");

  // Set up promise/future connection for async engine operations; add engine to profile asynchronously
  auto enginePromise = make_shared<promise<shared_ptr<ProtectionEngine>>>();
  auto engineFuture = enginePromise->get_future();
  profile->AddEngineAsync(engineSettings, enginePromise);
  std::shared_ptr<ProtectionEngine> engine;

  try
  {
    engine = engineFuture.get();
  }
  catch (const std::exception& e)
  {
    cout << "An exception occurred... is the access token incorrect/expired?\n\n"
         << e.what() << "'\n";
    system("pause");
    return 1;
  }

  // Application shutdown. Null out profile and engine, call ReleaseAllResources();
  // Application may crash at shutdown if resources aren't properly released.
  engine = nullptr;
  profile = nullptr;
  mMipContext->ShutDown();
  mMipContext = nullptr;

  return 0;
}
```

--------------------------------

### C++ main() function for MIP Policy profile and engine initialization

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-policy-app-initialization-cpp

This code initializes the MIP SDK by creating a MipContext, loading a PolicyProfile, and adding a PolicyEngine. It requires an auth_delegate class and profile_observer header. The application should build and test successfully, connecting to the Policy service.

```cpp
#include "mip/mip_context.h"
#include "mip/upe/policy_profile.h"
#include "auth_delegate.h"
#include "profile_observer.h"

#include <iostream>
#include <future>

using std::cout;
using std::endl;
using std::make_shared;
using std::shared_ptr;

int main()
{
    // Construct/initialize objects required by the application's profile object
    mip::ApplicationInfo appInfo{
        "your_app_id",                          // Application ID from Microsoft Entra app registration
        "MIP SDK Policy Quickstart",            // Friendly name
        "1.0"                                   // Version
    };

    auto mipConfiguration = make_shared<mip::MipConfiguration>(
        appInfo,                                // ApplicationInfo object
        "mip_data",                             // Path to store settings and logs
        mip::LogLevel::Trace,                   // Log level
        false,                                  // isOfflineOnly
        mip::CacheStorageType::OnDiskEncrypted  // Cache storage type
    );

    auto mipContext = mip::MipContext::Create(mipConfiguration);

    auto profileObserver = make_shared<PolicyProfileObserver>();

    auto authDelegateImpl = make_shared<sample::auth::AuthDelegateImpl>("your_app_id");

    mip::PolicyProfile::Settings profileSettings(mipContext,
        mip::CacheStorageType::OnDiskEncrypted,
        profileObserver
    );

    // Load Policy Profile
    auto profilePromise = make_shared<std::promise<shared_ptr<mip::PolicyProfile>>>();
    auto profileFuture = profilePromise->get_future();
    mip::PolicyProfile::LoadAsync(profileSettings, profilePromise);
    auto profile = profileFuture.get();

    // Add a Policy Engine
    mip::PolicyEngine::Settings engineSettings(
        mip::Identity("user@contoso.com"),
        authDelegateImpl,
        "",
        "en-US",
        false
    );

    auto enginePromise = make_shared<std::promise<shared_ptr<mip::PolicyEngine>>>();
    auto engineFuture = enginePromise->get_future();
    profile->AddEngineAsync(engineSettings, enginePromise);
    auto engine = engineFuture.get();

    // Application using Policy engine is ready. 
    // Engine can be used to list labels, compute actions, etc.

    cout << "Policy engine loaded successfully." << endl;

    return 0;
}
```

--------------------------------

### C++ code to construct File profile and engine

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-app-initialization-cpp

This snippet shows the complete main() implementation for initializing the MIP context, FileProfile, and FileEngine. It includes placeholder values for application ID, name, version, engine account, and engine state that must be replaced. The code sets up promise/future connections for asynchronous operations and handles exceptions during profile and engine loading.

```cpp
#include "mip/mip_context.h"  
#include "auth_delegate.h"
#include "consent_delegate.h"
#include "profile_observer.h"

using std::promise;
using std::future;
using std::make_shared;
using std::shared_ptr;
using std::string;
using std::cout;
using mip::ApplicationInfo;
using mip::FileProfile;
using mip::FileEngine;

int main()
{
  // Construct/initialize objects required by the application's profile object
  // ApplicationInfo object (App ID, name, version)
  ApplicationInfo appInfo{"<application-id>",      
                          "<application-name>",
                          "<application-version>"};

  // Create MipConfiguration object.
  std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(appInfo,
                                                                                                    "mip_data",
                                                                                                    mip::LogLevel::Trace,
                                                                                                    false,
                                                                                                    mip::CacheStorageType::OnDisk);


  std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

  auto profileObserver = make_shared<ProfileObserver>();                     // Observer object
  auto authDelegateImpl = make_shared<AuthDelegateImpl>("<application-id>"); // Authentication delegate object (App ID)                 
  auto consentDelegateImpl = make_shared<ConsentDelegateImpl>();             // Consent delegate object

  // Construct/initialize profile object
  FileProfile::Settings profileSettings(
                                mMipContext,
                                mip::CacheStorageType::OnDisk,
                                consentDelegateImpl,
                                profileObserver);

  // Set up promise/future connection for async profile operations; load profile asynchronously
  auto profilePromise = make_shared<promise<shared_ptr<FileProfile>>>();
  auto profileFuture = profilePromise->get_future();

  try
	  { 
		  mip::FileProfile::LoadAsync(profileSettings, profilePromise);
  }
	  catch (const std::exception& e)
	  {
		  cout << "An exception occurred... are the Settings and ApplicationInfo objects populated correctly?\n\n" << e.what() << "'\n";
			
		  system("pause");
		  return 1;
	  }
	  auto profile = profileFuture.get();

  // Construct/initialize engine object
  FileEngine::Settings engineSettings(
                                  mip::Identity("<engine-account>"), // Engine identity (account used for authentication)
                                  authDelegateImpl,		       // Token acquisition implementation
				    "<engine-state>",                  // User-defined engine state
                                  "en-US");                          // Locale (default = en-US)
                                  
  // Set the engineId for caching. 
  engineSettings.SetEngineId("<engine-account>");
  // Set up promise/future connection for async engine operations; add engine to profile asynchronously
  auto enginePromise = make_shared<promise<shared_ptr<FileEngine>>>();
  auto engineFuture = enginePromise->get_future();
  profile->AddEngineAsync(engineSettings, enginePromise);
  std::shared_ptr<FileEngine> engine; 
  try
  {
    engine = engineFuture.get();
  }
  catch (const std::exception& e)
  {
    cout << "An exception occurred... is the access token incorrect/expired?\n\n" << e.what() << "'\n";
     
    system("pause");
    return 1;
  }

  // Application shutdown. Null out profile and engine, call ReleaseAllResources();
  // Application may crash at shutdown if resources aren't properly released.
  // handler = nullptr; // This will be used in later quick starts.
  engine = nullptr;
  profile = nullptr;   
  mMipContext->ShutDown();
  mMipContext = nullptr;

  return 0;
  }
```

--------------------------------

### C# Example: Inspecting Label Protection Types

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-label-protection-types

Example code that iterates over sensitivity labels and prints the protection type.

```APIDOC
## C# Example: Inspecting Label Protection Types

### Description
Iterates over sensitivity labels from an engine and prints the protection type for each label.

### Code
```csharp
foreach (var label in engine.SensitivityLabels)
{
    Console.WriteLine($"Label: {label.Name}");

    if (label.HasRightsManagementPolicy)
    {
        if (label.HasDoNotForwardProtection)
            Console.WriteLine("  Protection type: Do Not Forward");
        else if (label.HasEncryptOnlyProtection)
            Console.WriteLine("  Protection type: Encrypt Only");
        else if (label.HasAdhocProtection)
            Console.WriteLine("  Protection type: Ad-hoc (user-defined permissions)");
        else
            Console.WriteLine("  Protection type: Template-based");
    }
    else
    {
        Console.WriteLine("  No protection");
    }
}
```
```

--------------------------------

### C++ Example: Inspecting Label Protection Types

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-label-protection-types

Example code that iterates over sensitivity labels and prints the protection type.

```APIDOC
## C++ Example: Inspecting Label Protection Types

### Description
Iterates over sensitivity labels from an engine and prints the protection type for each label.

### Code
```cpp
for (const auto& label : engine->ListSensitivityLabels()) {
    std::cout << "Label: " << label->GetName() << std::endl;

    if (label->HasRightsManagementPolicy()) {
        if (label->HasDoNotForwardProtection()) {
            std::cout << "  Protection type: Do Not Forward" << std::endl;
        } else if (label->HasEncryptOnlyProtection()) {
            std::cout << "  Protection type: Encrypt Only" << std::endl;
        } else if (label->HasAdhocProtection()) {
            std::cout << "  Protection type: Ad-hoc (user-defined permissions)" << std::endl;
        } else {
            std::cout << "  Protection type: Template-based" << std::endl;
        }
    } else {
        std::cout << "  No protection" << std::endl;
    }
}
```
```

--------------------------------

### Initialize MIP File SDK and create profile and engine in C#

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-app-initialization-csharp

This snippet shows the complete C# code for initializing the MIP File SDK, creating a profile and engine, and shutting down. Replace the placeholder values <application-id> and <friendly-name> with your actual values before building.

```csharp
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;
       }
  }
}
```

--------------------------------

### Create PolicyHandler with discovery auditing enabled and compute actions

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-handler-policy-auditing-cpp

This example creates a PolicyHandler with isAuditDiscoveryEnabled set to true, then calls ComputeActions() and GetSensitivityLabel() to generate discovery events. The SDK generates the discovery event only once per handler.

```cpp
// Create PolicyHandler, passing in true for isAuditDiscoveryEnabled
auto handler = mEngine->CreatePolicyHandler(true);

// Returns vector of mip::Action and generates discovery event.
auto actions = handler->ComputeActions(*state);

//Or, get the label for a given state
auto label = handler->GetSensitivityLabel(*state);
```

--------------------------------

### Java DeleteStoredData examples

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-delete-stored-data

Java examples for the ProtectionEngine.deleteStoredData() method. The first call deletes only expired cached data. The second call with 'true' deletes all cached data. The third call deletes cached data older than 30 days using a ZonedDateTime time point.

```java
// Delete only expired cached data
protectionEngine.deleteStoredData();

// Delete all cached data
protectionEngine.deleteStoredData(true);

// Delete cached data older than 30 days
ZonedDateTime thirtyDaysAgo = ZonedDateTime.now().minusDays(30);
protectionEngine.deleteStoredData(thirtyDaysAgo);
```

--------------------------------

### Create PolicyProfile::Settings with on-disk storage

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-profile-engine-policy-profile-cpp

Shows how to create a PolicyProfile::Settings object using mip::CacheStorageType::OnDisk for state storage. Requires a mip::MipContext initialized with application info and a PolicyProfileObserverImpl observer.

```cpp
mip::ApplicationInfo appInfo {clientId, "APP NAME", "1.2.3" };

std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
															  "mip_data",
                                                                                       		  mip::LogLevel::Trace,
                                                                                                  false);

std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

PolicyProfile::Settings profileSettings(
    mipContext,                                    // mipContext object
    mip::CacheStorageType::OnDisk,                 // use on disk storage
    std::make_shared<PolicyProfileObserverImpl>());  // new protection profile observer
```

--------------------------------

### C# code to construct a Protection profile and engine

Source: https://learn.microsoft.com/en-us/information-protection/develop/quick-protection-app-initialization-csharp

This snippet initializes the MIP Protection SDK, creates an ApplicationInfo with the client ID and app name, instantiates an AuthDelegateImplementation, creates a MipConfiguration and MipContext, loads a ProtectionProfile, and adds a ProtectionEngine. Replace the placeholder values <application-id> and <friendly-name> with your actual values before building.

```csharp
using System;
using System.Threading.Tasks;
using Microsoft.InformationProtection;
using Microsoft.InformationProtection.Exceptions;
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 Protection SDK operations.
               MIP.Initialize(MipComponent.Protection);

               // Create ApplicationInfo, setting the clientID from Azure AD 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, CacheStorageType.OnDiskEncrypted);

               // Create MipContext using Configuration
               MipContext mipContext = MIP.CreateMipContext(mipConfiguration);
                
               // Initialize and instantiate the ProtectionProfile.
               // Create the ProtectionProfileSettings object.
               // Initialize protection profile settings to create/use local state.
               var profileSettings = new ProtectionProfileSettings(mipContext,
                                        CacheStorageType.OnDiskEncrypted,                                        
                                        new ConsentDelegateImplementation());

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

               // Create a ProtectionEngineSettings object, then use that to add an engine to the profile.
               var engineSettings = new ProtectionEngineSettings("user1@tenant.com", authDelegate, "", "en-US");
               engineSettings.Identity = new Identity("user1@tenant.com");
               var protectionEngine = Task.Run(async () => await protectionProfile.AddEngineAsync(engineSettings)).Result;

               // Application Shutdown
               // handler = null; // This will be used in later quick starts.
               protectionEngine = null;
               protectionProfile = null;
               mipContext = null;
          }
     }
}

```

--------------------------------

### C++ DeleteStoredData examples

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-delete-stored-data

C++ examples for the ProtectionEngine::DeleteStoredData() method. The first call deletes only expired cached data (default behavior). The second call with 'true' deletes all cached data. The third call deletes cached data older than 30 days using a std::chrono::system_clock time point.

```cpp
#include "mip/protection/protection_engine.h"

// Delete only expired cached data (default behavior)
protectionEngine->DeleteStoredData();

// Delete all cached data
protectionEngine->DeleteStoredData(true);

// Delete cached data older than 30 days
auto thirtyDaysAgo = std::chrono::system_clock::now() - std::chrono::hours(24 * 30);
protectionEngine->DeleteStoredData(thirtyDaysAgo);
```

--------------------------------

### Clone MipSdk sample repository with Git Bash

Source: https://learn.microsoft.com/en-us/information-protection/develop/setup-configure-mip

Use this command in Git Bash to download a sample repository from the Azure-Samples MipSdk repositories. Replace <repo-name> with the actual repository name.

```bash
git clone https://github.com/azure-samples/<repo-name>
```

--------------------------------

### ExecutionStateOptions struct

Source: https://learn.microsoft.com/en-us/information-protection/develop/concept-handler-policy-executionstate-cpp

Example struct definition used to configure an ExecutionState implementation. This struct is passed to the constructor of the derived class.

```APIDOC
## ExecutionStateOptions

### Description
Defines a struct that holds configuration options for an `ExecutionState` implementation. The application sets these properties and passes the struct to the constructor of the derived class.

### Members
- **metadata** (`std::unordered_map<std::string, std::string>`) - Custom metadata to be applied.
- **newLabelId** (`std::string`) - The ID of the new label.
- **contentIdentifier** (`std::string`) - Human-readable identifier indicating the location of the object.
- **actionSource** (`mip::ActionSource`) - Source of the action (default: `MANUAL`).
- **dataState** (`mip::DataState`) - Data state of the object (default: `USE`).
- **assignmentMethod** (`mip::AssignmentMethod`) - Assignment method of the label (default: `STANDARD`).
- **isDowngradeJustified** (`bool`) - Whether downgrade is justified (default: `false`).
- **downgradeJustification** (`std::string`) - Justification for downgrade.
- **templateId** (`std::string`) - Template ID.
- **contentFormat** (`std::string`) - Content format (default: `mip::GetFileContentFormat()`).
- **supportedActions** (`mip::ActionType`) - Supported action types.
- **generateAuditEvent** (`bool`) - Whether to generate audit events.

### Example
```cpp
struct ExecutionStateOptions {
    std::unordered_map<std::string, std::string> metadata;
    std::string newLabelId;
    std::string contentIdentifier;
    mip::ActionSource actionSource = mip::ActionSource::MANUAL;
    mip::DataState dataState = mip::DataState::USE;
    mip::AssignmentMethod assignmentMethod = mip::AssignmentMethod::STANDARD;
    bool isDowngradeJustified = false;
    std::string downgradeJustification;
    std::string templateId;
    std::string contentFormat = mip::GetFileContentFormat();
    mip::ActionType supportedActions;
    bool generateAuditEvent;
};
```
```
Tokens:
Raw