fs_signature.h

浏览该文件的文档.

#ifndef FS_SIGNATURE_H_
#define FS_SIGNATURE_H_

#include "common/fs_common.h"
#include "common/file/fs_file.h"
#include "common/fs_image.h"
#include "pdf/interform/fs_pdfform.h"

namespace foxit {
namespace pdf {
  class PagingSealSignature;

class Signature;
FSDK_DEFINE_ARRAY(SignatureArray, Signature)


class Signature : public interform::Field {
 public:
  typedef enum _States {
    e_StateUnknown = 0x80000000,
    e_StateNoSignData = 0x00000200,
    e_StateUnsigned = 0x00000001,
    e_StateSigned = 0x00000002,
    e_StateVerifyValid = 0x00000004,
    e_StateVerifyInvalid = 0x00000008,
    e_StateVerifyErrorData = 0x00000010,
    e_StateVerifyNoSupportWay = 0x00000020,
    e_StateVerifyErrorByteRange = 0x00000040,
    e_StateVerifyChange = 0x00000080,
    e_StateVerifyIncredible = 0x00000100,
    e_StateVerifyNoChange = 0x00000400,
    e_StateVerifyIssueValid = 0x00001000,
    e_StateVerifyIssueUnknown = 0x00002000,
    e_StateVerifyIssueRevoke = 0x00004000,
    e_StateVerifyIssueExpire = 0x00008000,
    e_StateVerifyIssueUncheck = 0x00010000,
    e_StateVerifyIssueCurrent = 0x00020000,
    e_StateVerifyTimestampNone = 0x00040000,
    e_StateVerifyTimestampDoc = 0x00080000,
    e_StateVerifyTimestampValid = 0x00100000,
    e_StateVerifyTimestampInvalid = 0x00200000,
    e_StateVerifyTimestampExpire = 0x00400000,
    e_StateVerifyTimestampIssueUnknown = 0x00800000,
    e_StateVerifyTimestampIssueValid = 0x01000000,
    e_StateVerifyTimestampTimeBefore = 0x02000000,
    e_StateCertCannotGetVRI = 0x04000000,
    e_StateVerifyChangeLegal = 0x08000000,
    e_StateVerifyChangeIllegal = 0x10000000
  } States;
  
  typedef enum _APFlags {
    e_APFlagFoxitFlag = 0x0001,
    e_APFlagLabel = 0x0002,
    e_APFlagReason = 0x0004,
    e_APFlagSigningTime = 0x0008,
    e_APFlagDN = 0x0010,
    e_APFlagLocation = 0x0020,
    e_APFlagSigner = 0x0040,
    e_APFlagBitmap = 0x0080,
    e_APFlagText = 0x0100,
    e_APFlagFoxitEditorFlag = 0x0200,
    e_APFlagProducer = 0x0400
  } APFlags;
  
  typedef enum _KeyName {
    e_KeyNameSigner = 0,
    e_KeyNameLocation = 1,
    e_KeyNameReason = 2,
    e_KeyNameContactInfo = 3,
    e_KeyNameDN = 4,
    e_KeyNameText = 5,
    e_KeyNameProducer = 6
  } KeyName;
  
  typedef enum _DigestAlgorithm {
    e_DigestSHA1 = 0,
    e_DigestSHA256 = 1,
    e_DigestSHA384 = 2,
    e_DigestSHA512 = 3
  } DigestAlgorithm;
  
  typedef enum _SignatureType {
    e_SignatureTypeOrdinary = 0,
    e_SignatureTypeTimeStamp = 3,
    e_SignatureTypePagingSeal = 4
  } SignatureType;
  
  typedef enum _PAdESLevel {
    e_PAdESLevelNotPAdES = 0,
    e_PAdESLevelNone = 1,
    e_PAdESLevelBB = 2,
    e_PAdESLevelBT = 3,
    e_PAdESLevelBLT = 4,
    e_PAdESLevelBLTA = 5
  } PAdESLevel;
  
  typedef enum _DocPermission {
    e_DocPermUnrestricted = 0,
    e_DocPermNoChangesAllowed = 1,
    e_DocPermFillingFormAndSigning = 2,
    e_DocPermFillingFormSigningAndAnnotating = 3
  } DocPermission;
  
  typedef enum _FieldMDPAction {
    e_FieldMDPActionNone = 0,
    e_FieldMDPActionAll = 1,
    e_FieldMDPActionInclude = 2,
    e_FieldMDPActionExclude = 3
  } FieldMDPAction;
  
  typedef enum _LabelName {
    e_LabelNameSigner = 0,
    e_LabelNameLocation = 1,
    e_LabelNameReason = 2,
    e_LabelNameSignTime = 3,
    e_LabelNameDN = 4,
    e_LabelNameProducer = 6
  } LabelName;
  

  explicit Signature(const interform::Field& field);

  Signature(const foxit::pdf::PDFDoc& document, foxit::pdf::objects::PDFDictionary* sig_field_dict);

  ~Signature() {}

  bool IsEmpty() const;

  bool IsSigned();

  void SetDocPermission(DocPermission permission);

  DocPermission GetDocPermission();

  void SetFieldMDPActionFields(const FieldMDPAction& action, const WStringArray& field_array);

  FieldMDPAction GetFieldMDPAction();

  WStringArray GetFieldMDPActionFields();

  void EnableIncrementalSaveForFirstSigning(bool enable_incremental_save);

  common::Progressive StartSign(const wchar_t* cert_path, const WString& cert_password,
                                DigestAlgorithm digest_algorithm, const char* save_path,
                                const void* client_data = NULL, common::PauseCallback* pause = NULL);

  common::Progressive StartSign(foxit::common::file::StreamCallback* cert_file_stream, const WString& cert_password,
      DigestAlgorithm digest_algorithm, const char* save_path,
      const void* client_data = NULL, common::PauseCallback* pause = NULL);

   common::Progressive StartSign(const wchar_t* cert_path, const WString& cert_password,
      DigestAlgorithm digest_algorithm, const wchar_t* save_path,
      const void* client_data = NULL, common::PauseCallback* pause = NULL);

   common::Progressive StartSign(foxit::common::file::StreamCallback* cert_file_stream, const WString& cert_password,
       DigestAlgorithm digest_algorithm, const wchar_t* save_path,
       const void* client_data = NULL, common::PauseCallback* pause = NULL);

  common::Progressive StartSign(const wchar_t* cert_path, const foxit::WString& cert_password,
                                foxit::pdf::Signature::DigestAlgorithm digest_algorithm, foxit::common::file::StreamCallback* stream_callback,
                                const void* client_data = NULL, foxit::common::PauseCallback* pause = NULL);

   common::Progressive StartSign(foxit::common::file::StreamCallback* cert_file_stream, const foxit::WString& cert_password,
      foxit::pdf::Signature::DigestAlgorithm digest_algorithm, foxit::common::file::StreamCallback* stream_callback,
      const void* client_data = NULL, foxit::common::PauseCallback* pause = NULL);

  common::Progressive StartVerify(const void* client_data = NULL, common::PauseCallback* pause = NULL);

  String GetCertificateInfo(const char* key);

  bool GetByteRangeArray(uint32 out_byte_range_array[4]);

  uint32 GetState();

  bool ClearSignedData();

  PDFDoc GetDocument();

  PDFDoc GetSignedVersionDocument(const wchar_t* file_path);

  uint32 GetAppearanceFlags();

  void SetAppearanceFlags(uint32 appearance_flags);

  void SetAppearanceContent(const String& appearance_content);

  DateTime GetSignTime();

  void SetSignTime(const DateTime& sign_time);

  String GetFilter();

  void SetFilter(const char* filter);

  String GetSubFilter();

  void SetSubFilter(const char* sub_filter);

  WString GetKeyValue(KeyName key);

  void SetKeyValue(KeyName key, const wchar_t* value);

  void SetKeyLabel(LabelName label_name, const wchar_t* label_value);

  WString GetKeyLabel(LabelName label_name);

  common::Bitmap GetBitmap();

  void SetBitmap(const common::Bitmap& bitmap);

  void SetImage(const common::Image& image, int frame_index);

  void SetImage(const char* file_path, int frame_index);

  void SetImage(const wchar_t* file_path, int frame_index);

  objects::PDFDictionary* GetSignatureDict() const;

  void SetDefaultContentsLength(uint32 default_length);

  int32 GetCertCount() const;

  WString GetCert(int32 index) const;

  void SetCertChain(const WStringArray& cert_chain);

  SignatureType GetSignatureType();

  bool IsTimeStamp();

  PAdESLevel GetPAdESLevel();

  void SetCustomObject(const char* key, objects::PDFObject* pdf_object);

  SignatureArray GetPagingSealGroupElements();

  bool GenerateAppearance();

  PagingSealSignature GetPagingSealSignature();

  void EnableEmbedFont(bool enable_embed_font);

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

  bool DetectModification();
#endif
#ifndef __EMSCRIPTEN_RENDER__
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Signature(FS_HANDLE handle = NULL);
#endif
};

class SignatureCallback {
 public:
  typedef enum _CertValidity {
    e_CertValid = 0,
    e_CertExpired = 1,
    e_CertUnsupportType = 2,
    e_CertDataError = 3,
    e_CertInvalidPassword = 4,
    e_CertInvalidPath = 5,
    e_CertNotSet = 6,
    e_CertCannotGetPrivateKey = 7
  } CertValidity;
  

  virtual void Release() = 0;

  virtual bool StartCalcDigest(const common::file::ReaderCallback* file, const uint32* byte_range_array,
                               uint32 size_of_array, const Signature& signature, const void* client_data) = 0;

  virtual common::Progressive::State ContinueCalcDigest(const void* client_data,
                                                          const common::PauseCallback* pause) = 0;

  virtual String GetDigest(const void* client_data) = 0;

  virtual String Sign(const void* digest, uint32 digest_length, const wchar_t* cert_path,
                      const WString& cert_password, Signature::DigestAlgorithm digest_algorithm,
                      void* client_data) = 0;

  virtual String Sign(const void* digest, uint32 digest_length, foxit::common::file::StreamCallback* cert_file_stream,
      const WString& cert_password, Signature::DigestAlgorithm digest_algorithm,
      void* client_data) = 0;

  virtual uint32 VerifySigState(const void* digest, uint32 digest_length,
                                const void* signed_data, uint32 signed_data_len,
                                void* client_data) = 0;

  virtual bool IsNeedPadData() = 0;

  virtual CertValidity CheckCertificateValidity(const wchar_t* cert_path, const WString& cert_password, void* client_data) = 0;

 protected:
  ~SignatureCallback() {}
};

class TimeStampServer;

class TimeStampServerMgr FS_FINAL : public Object {
 public:
  static ErrorCode Initialize();
  static void Release();

  static int GetServerCount();
  static TimeStampServer GetServer(int index);
  static int GetServerIndex(const TimeStampServer& server);

  static TimeStampServer GetDefaultServer();
  static void SetDefaultServer(int index);
  static void SetDefaultServer(const TimeStampServer& server);

  static TimeStampServer AddServer(const WString& server_name, const WString& server_url, const WString& user_name, const WString& password);
  static void RemoveServer(int index);
  static void RemoveServer(const TimeStampServer& server);
};

class TimeStampServer FS_FINAL : public Base {
 public:
  typedef enum _SendRequestResult {
    e_SendResultSuccess = 0,
    e_SendResultFailToCreateSocket = 1,
    e_SendResultFailToConnect = 2,
    e_SendResultFailToSendData = 3,
    e_SendResultFailToReceiveData = 4,
    e_SendResultFailToRequest = 5,
    e_SendResultFailToGetData = 6,
    e_SendResultOutOfMemory = 7
  } SendRequestResult;
  

  TimeStampServer(const TimeStampServer& other);

  TimeStampServer& operator = (const TimeStampServer& other);

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

  ~TimeStampServer();

  bool IsEmpty() const;

  SendRequestResult SendTimeStampRequest(const String& request);

  String GetTimeStampMessage();

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

class TimeStampCallback {
 public:
  virtual void Release() = 0;

  virtual TimeStampServer::SendRequestResult SendTimeStampRequest(const String& request) = 0;

  virtual String GetTimeStampMessage() = 0;

 protected:
  virtual ~TimeStampCallback() {}
};

class PagingSealConfig FS_FINAL : public Object{
 public:
  typedef enum _PagingSealPosition {
    e_PagingSealPositionLeft = 1,
    e_PagingSealPositionRight = 2,
    e_PagingSealPositionTop = 3,
    e_PagingSealPositionBottom = 4
  } PagingSealPosition;
  
  typedef enum _PagingSealStyle {
    e_PagingSealStyleMultipleSignatures = 0,
    e_PagingSealStyleOneSignature = 1
  } PagingSealStyle;
  

  PagingSealConfig(PagingSealPosition paging_seal_position, float offset, float first_page_percent, bool is_on_perforation,
    PagingSealStyle paging_seal_style = PagingSealConfig::e_PagingSealStyleMultipleSignatures, bool is_display_multiple_seal = false, int page_count_for_each_seal = 30);

  PagingSealConfig& operator = (const PagingSealConfig& paging_seal_config) {
    this->paging_seal_position = paging_seal_config.paging_seal_position;
    this->offset = paging_seal_config.offset;
    this->first_page_percent = paging_seal_config.first_page_percent;
    this->is_on_perforation = paging_seal_config.is_on_perforation;
    this->paging_seal_style = paging_seal_config.paging_seal_style;
    this->is_display_multiple_seal = paging_seal_config.is_display_multiple_seal;
    this->page_count_for_each_seal = paging_seal_config.page_count_for_each_seal;
    return *this;
  }

  bool operator == (const PagingSealConfig& paging_seal_config) const {
    if (this->paging_seal_position == paging_seal_config.paging_seal_position &&
      this->offset == paging_seal_config.offset &&
      this->first_page_percent == paging_seal_config.first_page_percent &&
      this->is_on_perforation == paging_seal_config.is_on_perforation &&
      this->paging_seal_style == paging_seal_config.paging_seal_style &&
      this->is_display_multiple_seal == paging_seal_config.is_display_multiple_seal &&
      this->page_count_for_each_seal == paging_seal_config.page_count_for_each_seal){
      return true;
    }
    return false;
  }

  bool operator != (const PagingSealConfig& paging_seal_config) const {
    if (this->paging_seal_position != paging_seal_config.paging_seal_position ||
      this->offset != paging_seal_config.offset ||
      this->first_page_percent != paging_seal_config.first_page_percent ||
      this->is_on_perforation != paging_seal_config.is_on_perforation ||
      this->paging_seal_style != paging_seal_config.paging_seal_style ||
      this->is_display_multiple_seal != paging_seal_config.is_display_multiple_seal ||
      this->page_count_for_each_seal != paging_seal_config.page_count_for_each_seal) {
      return true;
    }
    return false;
  }

  void Set(PagingSealPosition paging_seal_position, float offset, float first_page_percent, bool is_on_perforation, PagingSealStyle paging_seal_style,
           bool is_display_multiple_seal = false, int page_count_for_each_seal = 30);

  PagingSealPosition paging_seal_position;
  float offset;
  float first_page_percent;
  bool is_on_perforation;
  PagingSealStyle paging_seal_style;
  bool is_display_multiple_seal;
  int page_count_for_each_seal;
};

class PagingSealSignature FS_FINAL : public pdf::Signature {
 public:
  typedef enum _PagingSealAPState {
    e_PagingSealAPStateUnknown = 0,
    e_PagingSealAPStateUnsigned = 1,
    e_PagingSealAPStateSigned = 2,
    e_PagingSealAPStateValid = 3,
    e_PagingSealAPStateInvalid = 4
  } PagingSealAPState;
  

  ~PagingSealSignature() {}

  void SetPagingSealConfig(PagingSealConfig paging_seal_config);

  void SetAPStateBitmap(PagingSealAPState ap_state, const common::Bitmap& bitmap);

  bool GenerateAppearance();

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

}  // namespace pdf
}  // namespace foxit
#endif  // FS_SIGNATURE_H_