1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
//========================================================================
//
// SecurityHandler.h
//
// Copyright 2004 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// All changes made under the Poppler project to this file are licensed
// under GPL version 2 or later
//
// Copyright (C) 2012, 2018 Albert Astals Cid <aacid@kde.org>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
#ifndef SECURITYHANDLER_H
#define SECURITYHANDLER_H
#include "poppler-config.h"
#include "Object.h"
class GooString;
class PDFDoc;
struct XpdfSecurityHandler;
//------------------------------------------------------------------------
// SecurityHandler
//------------------------------------------------------------------------
class SecurityHandler {
public:
static SecurityHandler *make(PDFDoc *docA, Object *encryptDictA);
SecurityHandler(PDFDoc *docA);
virtual ~SecurityHandler();
SecurityHandler(const SecurityHandler &) = delete;
SecurityHandler& operator=(const SecurityHandler &) = delete;
// Returns true if the file is actually unencrypted.
virtual bool isUnencrypted() { return false; }
// Check the document's encryption. If the document is encrypted,
// this will first try <ownerPassword> and <userPassword> (in
// "batch" mode), and if those fail, it will attempt to request a
// password from the user. This is the high-level function that
// calls the lower level functions for the specific security handler
// (requesting a password three times, etc.). Returns true if the
// document can be opened (if it's unencrypted, or if a correct
// password is obtained); false otherwise (encrypted and no correct
// password).
bool checkEncryption(const GooString *ownerPassword,
const GooString *userPassword);
// Create authorization data for the specified owner and user
// passwords. If the security handler doesn't support "batch" mode,
// this function should return NULL.
virtual void *makeAuthData(const GooString *ownerPassword,
const GooString *userPassword) = 0;
// Construct authorization data, typically by prompting the user for
// a password. Returns an authorization data object, or NULL to
// cancel.
virtual void *getAuthData() = 0;
// Free the authorization data returned by makeAuthData or
// getAuthData.
virtual void freeAuthData(void *authData) = 0;
// Attempt to authorize the document, using the supplied
// authorization data (which may be NULL). Returns true if
// successful (i.e., if at least the right to open the document was
// granted).
virtual bool authorize(void *authData) = 0;
// Return the various authorization parameters. These are only
// valid after authorize has returned true.
virtual int getPermissionFlags() = 0;
virtual bool getOwnerPasswordOk() = 0;
virtual unsigned char *getFileKey() = 0;
virtual int getFileKeyLength() = 0;
virtual int getEncVersion() = 0;
virtual int getEncRevision() = 0;
virtual CryptAlgorithm getEncAlgorithm() = 0;
protected:
PDFDoc *doc;
};
//------------------------------------------------------------------------
// StandardSecurityHandler
//------------------------------------------------------------------------
class StandardSecurityHandler: public SecurityHandler {
public:
StandardSecurityHandler(PDFDoc *docA, Object *encryptDictA);
~StandardSecurityHandler() override;
bool isUnencrypted() override;
void *makeAuthData(const GooString *ownerPassword,
const GooString *userPassword) override;
void *getAuthData() override;
void freeAuthData(void *authData) override;
bool authorize(void *authData) override;
int getPermissionFlags() override { return permFlags; }
bool getOwnerPasswordOk() override { return ownerPasswordOk; }
unsigned char *getFileKey() override { return fileKey; }
int getFileKeyLength() override { return fileKeyLength; }
int getEncVersion() override { return encVersion; }
int getEncRevision() override { return encRevision; }
CryptAlgorithm getEncAlgorithm() override { return encAlgorithm; }
private:
int permFlags;
bool ownerPasswordOk;
unsigned char fileKey[32];
int fileKeyLength;
int encVersion;
int encRevision;
bool encryptMetadata;
CryptAlgorithm encAlgorithm;
GooString *ownerKey, *userKey;
GooString *ownerEnc, *userEnc;
GooString *fileID;
bool ok;
};
#endif
|
