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

Coverage Report

Created: 2025-07-11 07:01