protection_handler.h

Go to the documentation of this file.

/*
 *
 * Copyright (c) Microsoft Corporation.
 * All rights reserved.
 *
 * This code is licensed under the MIT License.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files(the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions :
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */
#ifndef API_MIP_PROTECTION_PROTECTION_HANDLER_H_
#define API_MIP_PROTECTION_PROTECTION_HANDLER_H_
 
#include <chrono>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "mip/common_types.h"
#include "mip/mip_export.h"
#include "mip/mip_namespace.h"
#include "mip/protection_descriptor.h"
#include "mip/protection/protection_common_settings.h"
#include "mip/protection/protection_common_types.h"
#include "mip/protection/publishing_use_license_request.h"
#include "mip/stream.h"
#include "mip/user_rights.h"
#include "mip/user_roles.h"
 
MIP_NAMESPACE_BEGIN
 
class CryptoProvider;
 
class ProtectionHandler {
public:
  class Observer {
  public:
    virtual void OnCreateProtectionHandlerSuccess(
        const std::shared_ptr<ProtectionHandler>& protectionHandler,
        const std::shared_ptr<void>& context) { UNUSED(protectionHandler); UNUSED(context); };
 
    virtual void OnCreateProtectionHandlerFailure(
        const std::exception_ptr& error, 
        const std::shared_ptr<void>& context) { UNUSED(error); UNUSED(context); }
 
    virtual ~Observer() { }
  };
 
  class ConsumptionSettings : public ProtectionCommonSettings {
  public:
    ConsumptionSettings(const std::vector<uint8_t>& serializedPublishingLicense)
        : mLicenseInfo(std::make_shared<PublishingLicenseInfo>(serializedPublishingLicense)) {}
 
    ConsumptionSettings(
        const std::vector<uint8_t>& serializedPreLicense,
        const std::vector<uint8_t>& serializedPublishingLicense)
        : mLicenseInfo(std::make_shared<PublishingLicenseInfo>(serializedPreLicense, serializedPublishingLicense)) {}
 
    ConsumptionSettings(const std::shared_ptr<PublishingLicenseInfo>& licenseInfo)
        : mLicenseInfo(licenseInfo) {}
 
    std::shared_ptr<PublishingLicenseInfo> GetPublishingLicenseInfo() const {
      return mLicenseInfo;
    }
 
    void SetDelegatedUserEmail(const std::string& delegatedUserEmail) { mDelegatedUserEmail = delegatedUserEmail; }
 
    const std::string& GetDelegatedUserEmail() const { return mDelegatedUserEmail; }
 
    void SetContentName(const std::string& contentName) { mContentName = contentName;}
 
    const std::string& GetContentName() const { return mContentName; }
 
    MIP_API void AddRmsCapability(const std::string& capability);
 
    MIP_API bool RemoveRmsCapability(const std::string& capability);
 
    const std::shared_ptr<std::vector<std::string>> GetRmsCapabilities() const { 
      if (mCapabilities == nullptr) { return mCapabilities; } 
      return std::make_shared<std::vector<std::string>>(*mCapabilities);
    }
 
  private:
    std::shared_ptr<PublishingLicenseInfo> mLicenseInfo;
    std::string mDelegatedUserEmail;
    std::string mContentName;
    std::shared_ptr<std::vector<std::string>> mCapabilities;
  };
 
  class PublishingSettings : public ProtectionCommonSettings {
  public:
    PublishingSettings(const std::shared_ptr<ProtectionDescriptor>& protectionDescriptor)
        : mProtectionDescriptor(protectionDescriptor),
          mIsAuditedExtractionAllowed(false),
          mIsDeprecatedAlgorithmPreferred(false),
          mIsPublishingFormatJson(false),
          mRepairLabelIdAllowed(false),
          mRegenerateContentKey(false) {}
      
    PublishingSettings(
        const std::shared_ptr<ProtectionDescriptor>& protectionDescriptor,
        const std::vector<uint8_t>& serializedPublishingLicense)
        : mProtectionDescriptor(protectionDescriptor),
          mRepublishingLicense(serializedPublishingLicense),
          mIsAuditedExtractionAllowed(false),
          mIsDeprecatedAlgorithmPreferred(false),
          mIsPublishingFormatJson(false),
          mRepairLabelIdAllowed(false),
          mRegenerateContentKey(false) {}
 
    PublishingSettings(
        const std::shared_ptr<ProtectionDescriptor>& protectionDescriptor,
        const std::shared_ptr<ProtectionHandler>& protectionHandler)
        : mProtectionDescriptor(protectionDescriptor),
          mProtectionHandler(protectionHandler),
          mIsAuditedExtractionAllowed(false),
          mIsDeprecatedAlgorithmPreferred(false),
          mIsPublishingFormatJson(false),
          mRepairLabelIdAllowed(false),
          mRegenerateContentKey(false) {}
 
    std::shared_ptr<ProtectionDescriptor> GetProtectionDescriptor() const { return mProtectionDescriptor; }
 
    std::shared_ptr<ProtectionHandler> GetProtectionHandlerForRepublish() const { return mProtectionHandler; }
 
    bool GetIsAuditedExtractionAllowed() const { return mIsAuditedExtractionAllowed; }
 
    void SetIsAuditedExtractionAllowed(bool isAuditedExtractionAllowed) {
      mIsAuditedExtractionAllowed = isAuditedExtractionAllowed;
    }
 
    bool GetIsDeprecatedAlgorithmPreferred() const { return mIsDeprecatedAlgorithmPreferred; }
 
    void SetIsDeprecatedAlgorithmPreferred(bool isDeprecatedAlgorithmPreferred) {
      mIsDeprecatedAlgorithmPreferred = isDeprecatedAlgorithmPreferred;
    }
 
    void SetDelegatedUserEmail(const std::string& delegatedUserEmail) { mDelegatedUserEmail = delegatedUserEmail; }
 
    const std::string& GetDelegatedUserEmail() const { return mDelegatedUserEmail; }
 
    bool IsPublishingFormatJson() const { return mIsPublishingFormatJson; }
 
    void SetPublishingFormatJson(bool isPublishingFormatJson) {
      mIsPublishingFormatJson = isPublishingFormatJson;
    }
 
    bool GetRegenerateContentKey() const { return mRegenerateContentKey; }
 
    void SetRegenerateContentKey(bool regenerateContentKey) {
      mRegenerateContentKey = regenerateContentKey;
    }
 
#if !defined(SWIG) && !defined(SWIG_DIRECTORS)
    [[deprecated("SetPreLicenseUserEmail is deprecated, use SetRequestPreLicense")]]
#endif
    void SetPreLicenseUserEmail(const std::string& preLicenseUserEmail) {
      if(mPublishingUseLicenseRequest == nullptr) {
        mPublishingUseLicenseRequest = PublishingUseLicenseRequest::CreatePublishingUseLicenseRequest();
      }
      mPublishingUseLicenseRequest->SetDelegatedUserEmail(preLicenseUserEmail);
    }
 
#if !defined(SWIG) && !defined(SWIG_DIRECTORS)
    [[deprecated("GetPreLicenseUserEmail is deprecated, use GetPreLicenseRequest")]]
#endif
    const std::string& GetPreLicenseUserEmail() const {
      static std::string empty;
      return mPublishingUseLicenseRequest != nullptr ? mPublishingUseLicenseRequest->GetDelegatedUserEmail() : empty; }
 
    const std::vector<uint8_t>& GetPublishingLicenseForRepublish() const {
      return mRepublishingLicense;
    }
 
    void SetRequestPreLicense(std::shared_ptr<PublishingUseLicenseRequest> publishingUseLicenseRequest) {
      mPublishingUseLicenseRequest = publishingUseLicenseRequest;
    }
 
    std::shared_ptr<PublishingUseLicenseRequest> GetPreLicenseRequest() const {
      return mPublishingUseLicenseRequest;
    }
 
    bool GetRepairLabelIdAllowed() const { return mRepairLabelIdAllowed; }
 
    void SetRepairLabelIdAllowed(bool repairAllowed) {
      mRepairLabelIdAllowed = repairAllowed;
    }
 
    private:
      std::shared_ptr<ProtectionDescriptor> mProtectionDescriptor;
      std::vector<uint8_t> mRepublishingLicense;
      std::shared_ptr<ProtectionHandler> mProtectionHandler;
      bool mIsAuditedExtractionAllowed;
      bool mIsDeprecatedAlgorithmPreferred;
      bool mIsPublishingFormatJson;
      bool mRepairLabelIdAllowed;
      bool mRegenerateContentKey;
      std::string mDelegatedUserEmail;
      std::shared_ptr<PublishingUseLicenseRequest> mPublishingUseLicenseRequest;
  };
 
  enum class PreLicenseFormat {
    Xml,  
    Json, 
  };
 
  virtual std::shared_ptr<Stream> CreateProtectedStream(
      const std::shared_ptr<Stream>& backingStream,
      int64_t contentStartPosition,
      int64_t contentSize) = 0;
 
  virtual int64_t EncryptBuffer(
      int64_t offsetFromStart,
      const uint8_t* inputBuffer,
      int64_t inputBufferSize,
      uint8_t* outputBuffer,
      int64_t outputBufferSize,
      bool isFinal) = 0;
 
  virtual int64_t DecryptBuffer(
      int64_t offsetFromStart,
      const uint8_t* inputBuffer,
      int64_t inputBufferSize,
      uint8_t* outputBuffer,
      int64_t outputBufferSize,
      bool isFinal) = 0;
 
  virtual int64_t GetProtectedContentLength(int64_t unprotectedLength, bool includesFinalBlock) = 0;
 
  virtual int64_t GetBlockSize() = 0;
 
  virtual std::vector<std::string> GetRights() const = 0;
 
  virtual bool AccessCheck(const std::string& right) const = 0;
 
  virtual const std::string GetIssuedTo() = 0;
 
  virtual const std::string GetOwner() = 0;
 
  virtual bool IsIssuedToOwner() = 0;
 
  virtual std::shared_ptr<ProtectionDescriptor> GetProtectionDescriptor() = 0;
 
  virtual const std::string GetContentId() = 0;
 
  virtual bool DoesUseDeprecatedAlgorithms() = 0;
 
  virtual bool UsesApplicationDefinedPadding() = 0;
 
  virtual bool IsAuditedExtractAllowed() = 0;
 
  virtual const std::vector<uint8_t>& GetSerializedPublishingLicense() const = 0;
 
  virtual const std::vector<uint8_t>& GetSerializedPreLicense(PreLicenseFormat format) const = 0;
 
  virtual CipherMode GetCipherMode() const = 0;
 
  virtual const std::shared_ptr<CryptoProvider> GetCryptoProvider() = 0;
  virtual const std::shared_ptr<CryptoProvider>& GetPolicyCryptoProvider() const = 0;
  virtual ~ProtectionHandler() {}
 
};
 
MIP_NAMESPACE_END
#endif // API_MIP_PROTECTION_PROTECTION_HANDLER_H_