fs_security.h

Go to the documentation of this file.

#ifndef FS_SECURITY_H_
#define FS_SECURITY_H_

#include "common/fs_common.h"
#include "pdf/fs_pdfdoc.h"

namespace foxit {
namespace pdf {
// forward declaration
class CustomSecurityCallback;
class RMSSecurityCallback;

class SecurityHandler : public Base {
 public:
  typedef enum _CipherType {
    e_CipherNone = 0,
    e_CipherRC4 = 1,
    e_CipherAES = 2
  } CipherType;
  
  SecurityHandler();
#ifndef __EMSCRIPTEN_RENDER__

  SecurityHandler(const SecurityHandler& other);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit SecurityHandler(FS_HANDLE handle);

  virtual ~SecurityHandler();

  SecurityHandler& operator = (const SecurityHandler& other);
#endif

  bool operator == (const SecurityHandler& other);
  bool operator != (const SecurityHandler& other);

  bool IsEmpty() const;

  virtual PDFDoc::EncryptType GetSecurityType();

};

class StdEncryptData FS_FINAL {
 public:
  StdEncryptData(bool is_encrypt_metadata, uint32 user_permissions, SecurityHandler::CipherType cipher,
                 int key_length) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->user_permissions = user_permissions;
    this->cipher = cipher;
    this->key_length = key_length;
  }

  StdEncryptData()
      : is_encrypt_metadata(true)
      , user_permissions(0)
      , cipher(SecurityHandler::e_CipherNone)
      , key_length(0) {}

  StdEncryptData(const StdEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    user_permissions = other.user_permissions;
    cipher = other.cipher;
    key_length = other.key_length;
  }

  StdEncryptData& operator = (const StdEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    user_permissions = other.user_permissions;
    cipher = other.cipher;
    key_length = other.key_length;
    return *this;
  }

  bool operator == (const StdEncryptData& other) const {
    return (is_encrypt_metadata == other.is_encrypt_metadata &&
            user_permissions == other.user_permissions &&
            cipher == other.cipher &&
            key_length == other.key_length);
  }

  bool operator != (const StdEncryptData& other) const {
    return !(is_encrypt_metadata == other.is_encrypt_metadata &&
             user_permissions == other.user_permissions &&
             cipher == other.cipher &&
             key_length == other.key_length);
  }

  void Set(bool is_encrypt_metadata, uint32 user_permissions, SecurityHandler::CipherType cipher, int key_length) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->user_permissions = user_permissions;
    this->cipher = cipher;
    this->key_length = key_length;
  }

  bool is_encrypt_metadata;
  uint32 user_permissions;
  SecurityHandler::CipherType cipher;
  int key_length;
};

class StdSecurityHandler FS_FINAL : public SecurityHandler {
 public:
  typedef enum _ModifyFlag {
    e_ModifyPermission = 0x01,
    e_ModifyUserPassword = 0x02,
    e_ModifyOwnerPassword = 0x04
  } ModifyFlag;
  

  StdSecurityHandler();
  explicit StdSecurityHandler(const foxit::pdf::SecurityHandler& other);

  bool Initialize(const StdEncryptData& encrypt_data, const String& user_password, const String& owner_password);

  bool InitializeW(const StdEncryptData& encrypt_data, const WString& user_password, const WString& owner_password);

  void SetAES256ModifyFlags(uint32 modify_flags);
};

class CertificateEncryptData FS_FINAL {
 public:
  CertificateEncryptData(bool is_encrypt_metadata, SecurityHandler::CipherType cipher, const StringArray& envelopes) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->cipher = cipher;
    this->envelopes = envelopes;
  }

  CertificateEncryptData()
    : is_encrypt_metadata(true)
    , cipher(SecurityHandler::e_CipherNone) {}

  CertificateEncryptData(const CertificateEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    cipher = other.cipher;
    envelopes = other.envelopes;
  }

  CertificateEncryptData& operator = (const CertificateEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    cipher = other.cipher;
    envelopes = other.envelopes;
    return *this;
  }

  bool operator == (const CertificateEncryptData& other) const {
    if (is_encrypt_metadata == other.is_encrypt_metadata && cipher == other.cipher) {
      if (envelopes.GetSize() == other.envelopes.GetSize()) {
        for (size_t i=0; i<envelopes.GetSize(); i++) {
          if (envelopes[i] != other.envelopes[i]) return false;
        }
        return true;
      }
    }
    return false;
  }

  bool operator != (const CertificateEncryptData& other) const {
    if (!(is_encrypt_metadata == other.is_encrypt_metadata && cipher == other.cipher)) {
      if (envelopes.GetSize() == other.envelopes.GetSize()) {
        if (envelopes.GetSize() == 0) return false;
        for (size_t i=0; i<envelopes.GetSize(); i++) {
          if (envelopes[i] == other.envelopes[i]) return false;
        }
        return true;
      }
    }
    return false;
  }

  void Set(bool is_encrypt_metadata, SecurityHandler::CipherType cipher, const StringArray& envelopes) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->cipher = cipher;
    this->envelopes =envelopes;
  }

  bool is_encrypt_metadata;
  SecurityHandler::CipherType cipher;
  StringArray envelopes;
};

#if (_FX_OS_ == _FX_IOS_ || _FX_OS_ == _FX_ANDROID_ || defined(SWIG) || defined(__EMSCRIPTEN__)) && !defined(_SWIG_JAVA_) && !defined(_SWIG_DOTNET_) && !defined(_SWIG_PYTHON_) && !defined(_OC_) && !defined(_SWIG_MACOC_) && !defined(_SWIG_NODEJS_) && !defined(_SWIG_GO_) && !defined(_FSDK_NO_OPENSSL_)
struct CertPermission;
class Envelope : public Base {
 public:
  Envelope(const void* buffer, size_t size);
  Envelope(const char* cert_file_path);

  Envelope(const char* certFilePath, const CertPermission* permission);
  Envelope(foxit::common::file::ReaderCallback *certFile, const CertPermission* permission);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Envelope(FS_HANDLE handle);
  Envelope(const Envelope& other);

  virtual ~Envelope();

  bool operator==(const Envelope& other) const;
  bool operator!=(const Envelope& other) const;

  String GetDecryptionKey(const char* p12_file_path, const String& password);
};

enum PRINT_PERMISSION
{
    PRINT_NONE = 0,
    PRINT_LOW,
    PRINT_HIGH
};

enum CHANGE_PERMISSION
{
    CHANGE_NONE = 0,
    CHANGE_INSERTDELROTATE,
    CHANGE_FORMFILL,
    CHANGE_COMMENTSFORMFILL,
    CHANGE_ANYEXCEPTEXTRACT
};

enum PROPERTITY_PERMISSION
{
    PERMISSION_PRINTING = 0,            //Printing;
    PERMISSION_CHANGEDOC,            //Changing the Document;
    PERMISSION_DOCASSEMBLY,            //Document Assembly;
    PERMISSION_CONTENTCOPY,            //Content Copying;
    PERMISSION_CONTENTCOPYACCESS,    // Content Copying for Accessibility;
    PERMISSION_PAGEEXTRACT,            //Page Extraction;
    PERMISSION_COMMENT,                //Commenting;
    PERMISSION_FILLFORM,                //Filling of form fields;
    PERMISSION_SIGN                    //Signing;

};

struct CertPermission
{
    CertPermission()
    {
        bEnableCopy = false;
        bEnableTextAccess = false;
        printPer = PRINT_NONE;
        changePer = CHANGE_NONE;
    }

    bool bEnableCopy;
    bool bEnableTextAccess;

    PRINT_PERMISSION printPer;
    CHANGE_PERMISSION changePer;
};

typedef CFX_ArrayTemplate<Envelope> EnvelopeArray;

#endif

class CertificateSecurityHandler FS_FINAL : public SecurityHandler {
 public:
  CertificateSecurityHandler();
  explicit CertificateSecurityHandler(const foxit::pdf::SecurityHandler& other);

#if (_FX_OS_ == _FX_IOS_ || _FX_OS_ == _FX_ANDROID_ || defined(SWIG) || defined(__EMSCRIPTEN__)) && !defined(_SWIG_JAVA_) && !defined(_SWIG_DOTNET_) && !defined(_SWIG_PYTHON_) && !defined(_OC_) && !defined(_SWIG_MACOC_) && !defined(_SWIG_NODEJS_) && !defined(_SWIG_GO_) && !defined(_FSDK_NO_OPENSSL_)

  bool Initialize(foxit::pdf::EnvelopeArray envelopes, foxit::pdf::SecurityHandler::CipherType cipher, bool is_encrypt_metadata);
#endif  // (_FX_OS_ == _FX_IOS_ || _FX_OS_ == _FX_ANDROID_ || defined(SWIG)) && !defined(_SWIG_JAVA_) && !defined(_SWIG_DOTNET_) && !defined(_OC_) && !defined(_SWIG_MACOC_) && !defined(_SWIG_GO_)

  bool Initialize(const CertificateEncryptData& encrypt_data, const String& encrypt_key);
};

class DRMEncryptData FS_FINAL {
 public:
  DRMEncryptData(bool is_encrypt_metadata, const String& sub_filter, SecurityHandler::CipherType cipher,
    int key_length, bool is_owner, uint32 user_permissions) {
      this->is_encrypt_metadata = is_encrypt_metadata;
      this->sub_filter = sub_filter;
      this->cipher = cipher;
      this->key_length = key_length;
      this->is_owner = is_owner;
      this->user_permissions = user_permissions;
  }

  DRMEncryptData()
    : is_encrypt_metadata(true)
    , sub_filter("")
    , cipher(SecurityHandler::e_CipherNone)
    , key_length(0)
    , is_owner(false)
    , user_permissions(0) {}

  DRMEncryptData(const DRMEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    sub_filter = other.sub_filter;
    cipher = other.cipher;
    key_length = other.key_length;
    is_owner = other.is_owner;
    user_permissions = other.user_permissions;
  }

  DRMEncryptData& operator = (const DRMEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    sub_filter = other.sub_filter;
    cipher = other.cipher;
    key_length = other.key_length;
    is_owner = other.is_owner;
    user_permissions = other.user_permissions;
    return *this;
  }

  bool operator == (const DRMEncryptData& other) const {
    return (is_encrypt_metadata == other.is_encrypt_metadata &&
      sub_filter == other.sub_filter &&
      cipher == other.cipher && key_length == other.key_length &&
      is_owner == other.is_owner &&
      user_permissions == other.user_permissions);
  }

  bool operator != (const DRMEncryptData& other) const {
    return !(is_encrypt_metadata == other.is_encrypt_metadata &&
      sub_filter == other.sub_filter &&
      cipher == other.cipher && key_length == other.key_length &&
      is_owner == other.is_owner &&
      user_permissions == other.user_permissions);
  }

  void Set(bool is_encrypt_metadata, const String& sub_filter, SecurityHandler::CipherType cipher,
    int key_length, bool is_owner, uint32 user_permissions) {
      this->is_encrypt_metadata = is_encrypt_metadata;
      this->sub_filter = sub_filter;
      this->cipher = cipher;
      this->key_length = key_length;
      this->is_owner = is_owner;
      this->user_permissions = user_permissions;
  }

  bool is_encrypt_metadata;
  String sub_filter;
  SecurityHandler::CipherType cipher;
  int key_length;
  bool is_owner;
  uint32 user_permissions;
};

class DRMSecurityHandler FS_FINAL : public SecurityHandler {
 public:
  DRMSecurityHandler();
  explicit DRMSecurityHandler(const foxit::pdf::SecurityHandler& other);

  bool Initialize(const DRMEncryptData& encrypt_data, const char* file_id, const String& initial_key);
  WString GetDRMValue(const char* key);
  bool SetDRMValue(const char* key, const WString& value);

  bool VerifyEncryptionParams();
};

class CustomEncryptData FS_FINAL {
 public:
  CustomEncryptData(bool is_encrypt_metadata, const String& filter, const String& sub_filter) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->filter = filter;
    this->sub_filter = sub_filter;
  }

  CustomEncryptData()
    : is_encrypt_metadata(true)
    , filter("")
    , sub_filter("") {}

  CustomEncryptData(const CustomEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    filter = other.filter;
    sub_filter = other.sub_filter;
  }
  CustomEncryptData& operator = (const CustomEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    filter = other.filter;
    sub_filter = other.sub_filter;
    return *this;
  }

  bool operator == (const CustomEncryptData& other) const {
    return (is_encrypt_metadata == other.is_encrypt_metadata &&
      filter == other.filter && sub_filter == other.sub_filter);
  }

  bool operator != (const CustomEncryptData& other) const {
    return !(is_encrypt_metadata == other.is_encrypt_metadata &&
      filter == other.filter && sub_filter == other.sub_filter);
  }
  void Set(bool is_encrypt_metadata, const String& filter, const String& sub_filter) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->filter = filter;
    this->sub_filter = sub_filter;
  }

  bool is_encrypt_metadata;
  String filter;
  String sub_filter;
};

class CustomSecurityHandler FS_FINAL : public SecurityHandler {
 public:
  CustomSecurityHandler();
  explicit CustomSecurityHandler(const foxit::pdf::SecurityHandler& other);

  bool Initialize(const CustomEncryptData& encrypt_data,
                  const CustomSecurityCallback* callback, const char* encrypt_info = "");
};

class RMSEncryptData FS_FINAL {
 public:
  RMSEncryptData(bool is_encrypt_metadata, const char* publish_license, const StringArray& server_eul_list,
                 float irm_version = 1.0) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->publish_license = publish_license;
    this->server_eul_list = server_eul_list;
    if (irm_version<1.0)
      this->irm_version = 1.0;
    else
      this->irm_version = irm_version;
  }

  RMSEncryptData()
    : is_encrypt_metadata(true)
    , publish_license("")
    , irm_version(1.0) {}

  RMSEncryptData(const RMSEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    publish_license = other.publish_license;
    server_eul_list = other.server_eul_list;
    irm_version = other.irm_version;
  }

  RMSEncryptData& operator = (const RMSEncryptData& other) {
    is_encrypt_metadata = other.is_encrypt_metadata;
    publish_license = other.publish_license;
    server_eul_list = other.server_eul_list;
    irm_version = other.irm_version;
    return *this;
  }

  bool operator == (const RMSEncryptData& other) const {
    if (is_encrypt_metadata == other.is_encrypt_metadata && publish_license == other.publish_license &&
        fabs(irm_version - other.irm_version) <= FLT_EPSILON) {
      if (server_eul_list.GetSize() == other.server_eul_list.GetSize()) {
        for (size_t i=0; i<server_eul_list.GetSize(); i++) {
          if (server_eul_list[i] != other.server_eul_list[i]) return false;
        }
        return true;
      }
    }
    return false;
  }

  bool operator != (const RMSEncryptData& other) const {
    if (!(is_encrypt_metadata == other.is_encrypt_metadata && publish_license == other.publish_license &&
        fabs(irm_version - other.irm_version) <= FLT_EPSILON)) {
      if (server_eul_list.GetSize() == other.server_eul_list.GetSize()) {
        if (server_eul_list.GetSize() == 0) return false;
        for (size_t i=0; i<server_eul_list.GetSize(); i++) {
          if (server_eul_list[i] == other.server_eul_list[i]) return false;
        }
        return true;
      }
    }
    return false;
  }

  void Set(bool is_encrypt_metadata, const char* publish_license, const StringArray& server_eul_list,
           float irm_version = 1.0) {
    this->is_encrypt_metadata = is_encrypt_metadata;
    this->publish_license = publish_license;
    this->server_eul_list = server_eul_list;
    if (irm_version<1.0)
      this->irm_version = 1.0;
    else
      this->irm_version = irm_version;
  }

  bool is_encrypt_metadata;
  String publish_license;
  StringArray server_eul_list;
  float irm_version;
};

class RMSSecurityHandler FS_FINAL : public SecurityHandler {
 public:
  RMSSecurityHandler();
  explicit RMSSecurityHandler(const foxit::pdf::SecurityHandler& other);

  bool Initialize(const RMSEncryptData& encrypt_data, const RMSSecurityCallback* callback);
};

class SecurityCallback {
 public:
  virtual void Release() = 0;
  virtual PDFDoc::EncryptType GetSecurityType() {return PDFDoc::e_EncryptUnknown;}

 protected:
  ~SecurityCallback() {}
};

class CertificateSecurityCallback: public SecurityCallback {
 public:
  virtual PDFDoc::EncryptType GetSecurityType() FS_OVERRIDE {return PDFDoc::e_EncryptCertificate;}
  virtual String GetDecryptionKey(const void* envelope_buffer, uint32 envelope_length) = 0;

 protected:
  ~CertificateSecurityCallback() {}
};

class DRMSecurityCallback: public SecurityCallback {
 public:
  virtual PDFDoc::EncryptType GetSecurityType() FS_OVERRIDE {return PDFDoc::e_EncryptFoxitDRM;}
  virtual bool IsOwner(const PDFDoc& document, const char* sub_filter) = 0;
  virtual uint32 GetUserPermissions(const PDFDoc& document, const char* sub_filter) = 0;
  virtual SecurityHandler::CipherType GetCipherType(const PDFDoc& document, const char* sub_filter) = 0;
  virtual uint32 GetKeyLength(const PDFDoc& document, const char* sub_filter) = 0;
  virtual String GetFileID(const PDFDoc& document, const char* sub_filter) = 0;
  virtual String GetInitialKey(const PDFDoc& document, const char* sub_filter) = 0;

 protected:
  ~DRMSecurityCallback() {}
};

class CustomSecurityCallback: public SecurityCallback {
 public:
  virtual PDFDoc::EncryptType GetSecurityType() FS_OVERRIDE {return PDFDoc::e_EncryptCustom;}
  virtual void* CreateContext(const char* filter, const char* sub_filter, const char* encrypt_info) = 0;
  virtual bool ReleaseContext(void* context) = 0;
  virtual uint32 GetUserPermissions(const void* context, uint32 user_permission) = 0;
  virtual bool IsOwner(const void* context) = 0;
  virtual SecurityHandler::CipherType GetCipher(const void* context) = 0;
  virtual String GetEncryptKey(const void* context) = 0;
  virtual uint32 GetDecryptedSize(const void* context, uint32 src_data_size) = 0;
  virtual void* StartDecryptor(const void* context, int obj_num, int gen_num) = 0;
  virtual String DecryptData(const void* decryptor, const void* encrypted_data, uint32 encrypted_data_len) = 0;
  virtual String FinishDecryptor(void* decryptor) = 0;
  virtual uint32 GetEncryptedSize(const void* context, int obj_num, int gen_num,
                                  const void* src_data, uint32 src_data_len) = 0;
  virtual bool EncryptData(const void* context, int obj_num, int gen_num,
                           const void* src_data, uint32 src_data_len,
                           void* out_dst_buffer, uint32* out_dst_buffer_len) = 0;

  virtual bool UseStandardCryptoMethod(const void* context) { return false; }

 protected:
  ~CustomSecurityCallback() {}
};

class RMSSecurityCallback: public CustomSecurityCallback {
 public:
  virtual PDFDoc::EncryptType GetSecurityType() FS_OVERRIDE {return PDFDoc::e_EncryptRMS;}

 protected:
  ~RMSSecurityCallback() {}
};
}  // namespace pdf
}  // namespace foxit
#endif  // FS_SECURITY_H_