/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	364	{
13		#ifdef USE_INSECURE_RANDOM
14		static RandomDataProvider* insecure_random_data_provider =
15		InsecureRandomDataProvider::getInstance();
16		#else
17	364	static RandomDataProvider* insecure_random_data_provider = nullptr;
18	364	#endif
19	364	static RandomDataProvider* secure_random_data_provider =
20	364	SecureRandomDataProvider::getInstance();
21
22	364	static RandomDataProvider* provider =
23	364	(secure_random_data_provider ? secure_random_data_provider
24	364	: insecure_random_data_provider ? insecure_random_data_provider
25	363	: nullptr);
26
27	364	if (provider == nullptr) {
28	0	throw std::logic_error("QPDFCrypto_native has no random data provider");
29	0	}
30
31	364	return provider;
32	364	}
33
34		void
35		QPDFCrypto_native::provideRandomData(unsigned char* data, size_t len)
36	364	{
37	364	getRandomProvider()->provideRandomData(data, len);
38	364	}
39
40		void
41		QPDFCrypto_native::MD5_init()
42	87.5k	{
43	87.5k	md5 = std::make_shared<MD5_native>();
44	87.5k	}
45
46		void
47		QPDFCrypto_native::MD5_update(unsigned char const* data, size_t len)
48	4.59M	{
49	4.59M	md5->update(const_cast<unsigned char*>(data), len);
50	4.59M	}
51
52		void
53		QPDFCrypto_native::MD5_finalize()
54	87.1k	{
55	87.1k	md5->finalize();
56	87.1k	}
57
58		void
59		QPDFCrypto_native::MD5_digest(MD5_Digest d)
60	71.6k	{
61	71.6k	md5->digest(d);
62	71.6k	}
63
64		void
65		QPDFCrypto_native::RC4_init(unsigned char const* key_data, int key_len)
66	21.2k	{
67	21.2k	rc4 = std::make_shared<RC4_native>(key_data, key_len);
68	21.2k	}
69
70		void
71		QPDFCrypto_native::RC4_process(unsigned char const* in_data, size_t len, unsigned char* out_data)
72	21.2k	{
73	21.2k	rc4->process(in_data, len, out_data);
74	21.2k	}
75
76		void
77		QPDFCrypto_native::RC4_finalize()
78	0	{
79	0	}
80
81		void
82		QPDFCrypto_native::SHA2_init(int bits)
83	144k	{
84	144k	sha2 = std::make_shared<SHA2_native>(bits);
85	144k	}
86
87		void
88		QPDFCrypto_native::SHA2_update(unsigned char const* data, size_t len)
89	145k	{
90	145k	sha2->update(data, len);
91	145k	}
92
93		void
94		QPDFCrypto_native::SHA2_finalize()
95	144k	{
96	144k	sha2->finalize();
97	144k	}
98
99		std::string
100		QPDFCrypto_native::SHA2_digest()
101	144k	{
102	144k	return sha2->getRawDigest();
103	144k	}
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	157k	{
114	157k	aes_pdf = std::make_shared<AES_PDF_native>(encrypt, key_data, key_len, cbc_mode, cbc_block);
115	157k	}
116
117		void
118		QPDFCrypto_native::rijndael_process(unsigned char* in_data, unsigned char* out_data)
119	39.8M	{
120	39.8M	aes_pdf->update(in_data, out_data);
121	39.8M	}
122
123		void
124		QPDFCrypto_native::rijndael_finalize()
125	156k	{
126	156k	}

Coverage Report

Created: 2025-07-12 06:27