Utveckla ditt program

  • Artikel

Viktigt

Versioner av Microsoft Rights Management Service SDK som släpptes före mars 2020 är inaktuella. program som använder tidigare versioner måste uppdateras för att använda mars 2020-versionen. Fullständig information finns i utfasningsmeddelandet.

Inga ytterligare förbättringar planeras för Microsoft Rights Management Service SDK. Vi rekommenderar starkt att du använder Microsoft Information Protection SDK för klassificerings-, märknings- och skyddstjänster.

I det här exemplet ska du skapa ett enkelt konsolprogram som samverkar med Azure Information Protection-tjänsten (AIP). Som utgångspunkt används en sökväg till ett dokument som ska skyddas, sedan skyddas det med en ad hoc-princip eller en Azure-mall. Programmet tillämpar därefter korrekta principer enligt indata och skapar ett informationsskyddat dokument. Du kommer att använda exempelkoden Azure IP test application och den finns på Github.

Exempelapp – krav

  • Operativsystem: Windows 10, Windows 8, Windows 7, Windows Server 2008, Windows Server 2008 R2 eller Windows Server 2012
  • Programmeringsspråk: C# (.NET Framework 3.0 och senare)
  • Utvecklingsmiljö: Visual Studio 2015 (och senare)

Inställning av din Azure-konfiguration

Inställningen av Azure för det här programmet kräver att du skapar ett klient-ID, en symmetrisk nyckel och ett ägar-ID för programmet.

Azure AD-klient-konfigurering

Om du vill konfigurera Azure AD miljö för Azure Information Protection följer du anvisningarna i Aktivera skyddstjänsten från Azure Information Protection.

När tjänsten har aktiverats behöver du PowerShell-komponenter för nästa steg. Följ Administrera skydd från Azure Information Protection med hjälp av PowerShell för att åstadkomma detta.

Få ditt klient-ID

  • Kör PowerShell som administratör.
  • Importera RMS-modulen:Import-Module AIPService
  • Anslut till tjänsten med de tilldelade autentiseringsuppgifterna:Connect-AipService –Verbose
  • Kontrollera RMS är aktiverat:enable-aipservice
  • Få ditt klient-ID genom att köra:Get-AipServiceConfiguration

Spara värdet för BPOSId (klient-ID). Du behöver det vid senare steg.

Exempel på utdataför cmdleten Get-AadrmConfiguration

  • Koppla bort tjänsten:Disconnect-AipServiceService

Skapa tjänstens huvudnamn

Följ anvisningarna för att skapa ett huvudnamn för tjänsten:

Tjänstens huvudnamn är autentiseringsuppgifter som konfigurerats globalt för åtkomstkontroll som tillåter en tjänst att autentisera med hjälp av Microsoft Azure AD och att skydda information med hjälp av Microsoft Azure AD Rights Management

  • Kör PowerShell som administratör
  • Importera Microsoft Azure AD-modulen med hjälp av:Import-Module MSOnline
  • Anslut till din online-tjänst med de tilldelade autentiseringsuppgifterna:Connect-MsolService
  • Skapa ett nytt huvudnamn för tjänsten genom att köra:New-MsolServicePrincipal
  • Ange ett namn för din tjänst

    Spara den symmetriska nyckeln och programmets ägar-ID för framtida användning.

Utdata förNewMsolServicePrincipal-cmdlet-utdata

  • Lägg till programmets ägar-ID, symmetriska nyckel och klient-ID till programmets App.config-fil.

Exempelfil App.configApp.config fil

  • ClientID och RedirectUri kommer att vara tillgängliga för dig från när du registrerade ditt program i Azure. Mer information om hur du registrerar ditt program i Azure och får ClientID och RedirectUri finns i Konfigurera Azure RMS för ADAL-autentisering.

Designsammanfattning

Följande diagram visar en arkitektur och ett processflöde för den app som du skapar, stegen beskrivs nedan. designsammanfattning

  1. Användarindata:
    • Sökvägen till filen som ska skyddas
    • Väljer en mall eller skapar en ad hoc-princip
  2. Programmet begär autentisering med AIP.
  3. AIP bekräftar autentisering
  4. Programmet begär mallar från AIP.
  5. AIP returnerar fördefinierade mallar.
  6. Programmet lokaliserar den specificerade filen med angiven plats.
  7. Programmet tillämpar AIP-skyddsprincipen på filen.

Så här fungerar koden

I exemplet, Azure IP Test, börjar lösningen med filen Iprotect.cs. Det här är ett C#-konsolprogram och precis som med alla andra AIP-aktiverade program så börjar du med att läsa in MSIPC.dll enligt main()-metoden.

//Loads MSIPC.dll
SafeNativeMethods.IpcInitialize();
SafeNativeMethods.IpcSetAPIMode(APIMode.Server);

Läs in de parametrar som behövs för att ansluta till Azure

//Loads credentials for the service principal from App.Config
SymmetricKeyCredential symmetricKeyCred = new SymmetricKeyCredential();
symmetricKeyCred.AppPrincipalId = ConfigurationManager.AppSettings["AppPrincipalId"];
symmetricKeyCred.Base64Key = ConfigurationManager.AppSettings["Base64Key"];
symmetricKeyCred.BposTenantId = ConfigurationManager.AppSettings["BposTenantId"];

När du anger sökvägen i konsolprogrammet kontrollerar programmet om dokumentet redan är krypterat. Metoden är av klassen SafeFileApiNativeMethods.

var checkEncryptionStatus = SafeFileApiNativeMethods.IpcfIsFileEncrypted(filePath);

Om dokumentet inte är krypterat fortsätter den sedan att kryptera dokumentet med valet som anges i prompten.

if (!checkEncryptionStatus.ToString().ToLower().Contains(alreadyEncrypted))
{
  if (method == EncryptionMethod1)
  {
    //Encrypt a file via AIP template
    ProtectWithTemplate(symmetricKeyCred, filePath);

  }
  else if (method == EncryptionMethod2)
  {
    //Encrypt a file using ad-hoc policy
    ProtectWithAdHocPolicy(symmetricKeyCred, filePath);
  }
}

Alternativet skydda med mall fortsätter med att hämta mallistan från servern och ger användaren möjlighet att välja.

Om du inte modifierat mallar får du sedan standardmallar från AIP

public static void ProtectWithTemplate(SymmetricKeyCredential symmetricKeyCredential, string filePath)
{
  // Gets the available templates for this tenant
  Collection<TemplateInfo> templates = SafeNativeMethods.IpcGetTemplateList(null, false, true,
      false, true, null, null, symmetricKeyCredential);

  //Requests tenant template to use for encryption
  Console.WriteLine("Please select the template you would like to use to encrypt the file.");

  //Outputs templates available for selection
  int counter = 0;
  for (int i = 0; i < templates.Count; i++)
  {
    counter++;
    Console.WriteLine(counter + ". " + templates.ElementAt(i).Name + "\n" +
        templates.ElementAt(i).Description);
  }

  //Parses template selection
  string input = Console.ReadLine();
  int templateSelection;
  bool parseResult = Int32.TryParse(input, out templateSelection);

  //Returns error if no template selection is entered
  if (parseResult)
  {
    //Ensures template value entered is valid
    if (0 < templateSelection && templateSelection <= counter)
    {
      templateSelection -= templateSelection;

      // Encrypts the file using the selected template
      TemplateInfo selectedTemplateInfo = templates.ElementAt(templateSelection);

      string encryptedFilePath = SafeFileApiNativeMethods.IpcfEncryptFile(filePath,
          selectedTemplateInfo.TemplateId,
          SafeFileApiNativeMethods.EncryptFlags.IPCF_EF_FLAG_KEY_NO_PERSIST, true, false, true, null,
          symmetricKeyCredential);
    }
  }
}

Om du väljer ad-hoc-princip måste användare av programmet ange e-postmeddelanden för de personer som ska ha rättigheter. I det här avsnittet skapas licensen med hjälp av metoden IpcCreateLicenseFromScratch() och tillämpar den nya principen på mallen.

if (issuerDisplayName.Trim() != "")
{
  // Gets the available issuers of rights policy templates.
  // The available issuers is a list of RMS servers that this user has already contacted.
  try
  {
    Collection<TemplateIssuer> templateIssuers = SafeNativeMethods.IpcGetTemplateIssuerList(
                                                    null,
                                                    true,
                                                    false,
                                                    false, true, null, symmetricKeyCredential);

    // Creates the policy and associates the chosen user rights with it
    SafeInformationProtectionLicenseHandle handle = SafeNativeMethods.IpcCreateLicenseFromScratch(
                                                        templateIssuers.ElementAt(0));
    SafeNativeMethods.IpcSetLicenseOwner(handle, owner);
    SafeNativeMethods.IpcSetLicenseUserRightsList(handle, userRights);
    SafeNativeMethods.IpcSetLicenseDescriptor(handle, new TemplateInfo(null, CultureInfo.CurrentCulture,
                                                            policyName,
                                                            policyDescription,
                                                            issuerDisplayName,
                                                            false));

    //Encrypts the file using the ad hoc policy
    string encryptedFilePath = SafeFileApiNativeMethods.IpcfEncryptFile(
                                    filePath,
                                    handle,
                                    SafeFileApiNativeMethods.EncryptFlags.IPCF_EF_FLAG_KEY_NO_PERSIST,
                                    true,
                                    false,
                                    true,
                                    null,
                                    symmetricKeyCredential);
    }
}

Exempel på användarinteraktion

När du skapat allt och kör ska utdata för programmet se ut ungefär som följer:

  1. Du uppmanas att välja en krypteringsmetod. apputdata – steg 1

  2. Du uppmanas att ange sökvägen till filen som ska skyddas. apputdata – steg 2

  3. Du uppmanas att ange en licensägares e-post (den här ägaren måste ha behörigheter som global administratör i Azure AD-klienten). apputdata – steg 3

  4. Du anger e-postadresser till användare som har behörighet att komma åt filen (e-postadresserna måste avgränsas med blanksteg). apputdata – steg 4

  5. Du väljer från en lista över rättigheter som ska ges till behöriga användare. apputdata – steg 5

  6. Slutligen anger du några principmetadata: principnamn, beskrivning och utfärdare (Azure AD klientorganisation) utdata från appens visningsnamn – steg 6