/src/qpdf/libqpdf/QPDFCrypto_native.cc

Source (jump to first uncovered line)
#include <qpdf/QPDFCrypto_native.hh>

#include <qpdf/QUtil.hh>

#ifdef USE_INSECURE_RANDOM
# include <qpdf/InsecureRandomDataProvider.hh>
#endif
#include <qpdf/SecureRandomDataProvider.hh>

static RandomDataProvider*
getRandomProvider()
{
#ifdef USE_INSECURE_RANDOM
    static RandomDataProvider* insecure_random_data_provider =
        InsecureRandomDataProvider::getInstance();
#else
    static RandomDataProvider* insecure_random_data_provider = nullptr;
#endif
    static RandomDataProvider* secure_random_data_provider =
        SecureRandomDataProvider::getInstance();

    static RandomDataProvider* provider =
        (secure_random_data_provider         ? secure_random_data_provider
             : insecure_random_data_provider ? insecure_random_data_provider
                                             : nullptr);

    if (provider == nullptr) {
        throw std::logic_error("QPDFCrypto_native has no random data provider");
    }

    return provider;
}

void
QPDFCrypto_native::provideRandomData(unsigned char* data, size_t len)
{
    getRandomProvider()->provideRandomData(data, len);
}

void
QPDFCrypto_native::MD5_init()
{
    md5 = std::make_shared<MD5_native>();
}

void
QPDFCrypto_native::MD5_update(unsigned char const* data, size_t len)
{
    md5->update(const_cast<unsigned char*>(data), len);
}

void
QPDFCrypto_native::MD5_finalize()
{
    md5->finalize();
}

void
QPDFCrypto_native::MD5_digest(MD5_Digest d)
{
    md5->digest(d);
}

void
QPDFCrypto_native::RC4_init(unsigned char const* key_data, int key_len)
{
    rc4 = std::make_shared<RC4_native>(key_data, key_len);
}

void
QPDFCrypto_native::RC4_process(unsigned char const* in_data, size_t len, unsigned char* out_data)
{
    rc4->process(in_data, len, out_data);
}

void
QPDFCrypto_native::RC4_finalize()
{
}

void
QPDFCrypto_native::SHA2_init(int bits)
{
    sha2 = std::make_shared<SHA2_native>(bits);
}

void
QPDFCrypto_native::SHA2_update(unsigned char const* data, size_t len)
{
    sha2->update(data, len);
}

void
QPDFCrypto_native::SHA2_finalize()
{
    sha2->finalize();
}

std::string
QPDFCrypto_native::SHA2_digest()
{
    return sha2->getRawDigest();
}

void
QPDFCrypto_native::rijndael_init(
    bool encrypt,
    unsigned char const* key_data,
    size_t key_len,
    bool cbc_mode,
    unsigned char* cbc_block)

{
    aes_pdf = std::make_shared<AES_PDF_native>(encrypt, key_data, key_len, cbc_mode, cbc_block);
}

void
QPDFCrypto_native::rijndael_process(unsigned char* in_data, unsigned char* out_data)
{
    aes_pdf->update(in_data, out_data);
}

void
QPDFCrypto_native::rijndael_finalize()
{
}

Line	Count	Source (jump to first uncovered line)
1		#include <qpdf/QPDFCrypto_native.hh>
2
3		#include <qpdf/QUtil.hh>
4
5		#ifdef USE_INSECURE_RANDOM
6		# include <qpdf/InsecureRandomDataProvider.hh>
7		#endif
8		#include <qpdf/SecureRandomDataProvider.hh>
9
10		static RandomDataProvider*
11		getRandomProvider()
12	143k	{
13		#ifdef USE_INSECURE_RANDOM
14		static RandomDataProvider* insecure_random_data_provider =
15		InsecureRandomDataProvider::getInstance();
16		#else
17	143k	static RandomDataProvider* insecure_random_data_provider = nullptr;
18	143k	#endif
19	143k	static RandomDataProvider* secure_random_data_provider =
20	143k	SecureRandomDataProvider::getInstance();
21
22	143k	static RandomDataProvider* provider =
23	143k	(secure_random_data_provider ? secure_random_data_provider
24	143k	: insecure_random_data_provider ? insecure_random_data_provider
25	143k	: nullptr);
26
27	143k	if (provider == nullptr) {
28	0	throw std::logic_error("QPDFCrypto_native has no random data provider");
29	0	}
30
31	143k	return provider;
32	143k	}
33
34		void
35		QPDFCrypto_native::provideRandomData(unsigned char* data, size_t len)
36	143k	{
37	143k	getRandomProvider()->provideRandomData(data, len);
38	143k	}
39
40		void
41		QPDFCrypto_native::MD5_init()
42	86.9k	{
43	86.9k	md5 = std::make_shared<MD5_native>();
44	86.9k	}
45
46		void
47		QPDFCrypto_native::MD5_update(unsigned char const* data, size_t len)
48	91.2k	{
49	91.2k	md5->update(const_cast<unsigned char*>(data), len);
50	91.2k	}
51
52		void
53		QPDFCrypto_native::MD5_finalize()
54	86.9k	{
55	86.9k	md5->finalize();
56	86.9k	}
57
58		void
59		QPDFCrypto_native::MD5_digest(MD5_Digest d)
60	86.9k	{
61	86.9k	md5->digest(d);
62	86.9k	}
63
64		void
65		QPDFCrypto_native::RC4_init(unsigned char const* key_data, int key_len)
66	34.5k	{
67	34.5k	rc4 = std::make_shared<RC4_native>(key_data, key_len);
68	34.5k	}
69
70		void
71		QPDFCrypto_native::RC4_process(unsigned char const* in_data, size_t len, unsigned char* out_data)
72	34.6k	{
73	34.6k	rc4->process(in_data, len, out_data);
74	34.6k	}
75
76		void
77		QPDFCrypto_native::RC4_finalize()
78	0	{
79	0	}
80
81		void
82		QPDFCrypto_native::SHA2_init(int bits)
83	2.35M	{
84	2.35M	sha2 = std::make_shared<SHA2_native>(bits);
85	2.35M	}
86
87		void
88		QPDFCrypto_native::SHA2_update(unsigned char const* data, size_t len)
89	2.40M	{
90	2.40M	sha2->update(data, len);
91	2.40M	}
92
93		void
94		QPDFCrypto_native::SHA2_finalize()
95	2.35M	{
96	2.35M	sha2->finalize();
97	2.35M	}
98
99		std::string
100		QPDFCrypto_native::SHA2_digest()
101	2.35M	{
102	2.35M	return sha2->getRawDigest();
103	2.35M	}
104
105		void
106		QPDFCrypto_native::rijndael_init(
107		bool encrypt,
108		unsigned char const* key_data,
109		size_t key_len,
110		bool cbc_mode,
111		unsigned char* cbc_block)
112
113	2.45M	{
114	2.45M	aes_pdf = std::make_shared<AES_PDF_native>(encrypt, key_data, key_len, cbc_mode, cbc_block);
115	2.45M	}
116
117		void
118		QPDFCrypto_native::rijndael_process(unsigned char* in_data, unsigned char* out_data)
119	703M	{
120	703M	aes_pdf->update(in_data, out_data);
121	703M	}
122
123		void
124		QPDFCrypto_native::rijndael_finalize()
125	2.45M	{
126	2.45M	}

Coverage Report

Created: 2025-07-11 07:02