7084950926

Committed 04 Dec 2023 10:03AM UTC coverage: 57.644% (-0.01%) from 57.658%

Build # 7084950926

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13522 from rgacogne/coverity-auto-copy-move-2

Fix unnecessary copies reported by Coverity (round 2)

Run Details

31643 of 86054 branches covered (0.0%)

Branch coverage included in aggregate %.

13 of 24 new or added lines in 9 files covered. (54.17%)

48 existing lines in 14 files now uncovered.

106642 of 153841 relevant lines covered (69.32%)

4049443.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.83

/pdns/sodcrypto.cc

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#include <iostream>
#include <arpa/inet.h>

#include "namespaces.hh"
#include "noinitvector.hh"
#include "misc.hh"
#include "base64.hh"
#include "sodcrypto.hh"

#ifdef HAVE_LIBSODIUM

string newKey(bool base64Encoded)
{
  std::string key;
  key.resize(crypto_secretbox_KEYBYTES);

  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  randombytes_buf(reinterpret_cast<unsigned char*>(key.data()), key.size());

  if (!base64Encoded) {
    return key;
  }
  return "\"" + Base64Encode(key) + "\"";
}

bool sodIsValidKey(const std::string& key)
{
  return key.size() == crypto_secretbox_KEYBYTES;
}

std::string sodEncryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
{
  if (!sodIsValidKey(key)) {
    throw std::runtime_error("Invalid encryption key of size " + std::to_string(key.size()) + " (" + std::to_string(crypto_secretbox_KEYBYTES) + " expected), use setKey() to set a valid key");
  }

  std::string ciphertext;
  ciphertext.resize(msg.length() + crypto_secretbox_MACBYTES);
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  crypto_secretbox_easy(reinterpret_cast<unsigned char*>(ciphertext.data()),
                        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
                        reinterpret_cast<const unsigned char*>(msg.data()),
                        msg.length(),
                        nonce.value.data(),
                        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
                        reinterpret_cast<const unsigned char*>(key.data()));

  if (incrementNonce) {
    nonce.increment();
  }

  return ciphertext;
}

std::string sodDecryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
{
  std::string decrypted;

  if (msg.length() < crypto_secretbox_MACBYTES) {
    throw std::runtime_error("Could not decrypt message of size " + std::to_string(msg.length()));
  }

  if (!sodIsValidKey(key)) {
    throw std::runtime_error("Invalid decryption key of size " + std::to_string(key.size()) + ", use setKey() to set a valid key");
  }

  decrypted.resize(msg.length() - crypto_secretbox_MACBYTES);

  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  if (crypto_secretbox_open_easy(reinterpret_cast<unsigned char*>(decrypted.data()),
                                 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
                                 reinterpret_cast<const unsigned char*>(msg.data()),
                                 msg.length(),
                                 nonce.value.data(),
                                 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
                                 reinterpret_cast<const unsigned char*>(key.data())) != 0) {
    throw std::runtime_error("Could not decrypt message, please check that the key configured with setKey() is correct");
  }

  if (incrementNonce) {
    nonce.increment();
  }

  return decrypted;
}

void SodiumNonce::init()
{
  randombytes_buf(value.data(), value.size());
}

void SodiumNonce::merge(const SodiumNonce& lower, const SodiumNonce& higher)
{
  constexpr size_t halfSize = std::tuple_size<decltype(value)>{} / 2;
  memcpy(value.data(), lower.value.data(), halfSize);
  memcpy(value.data() + halfSize, higher.value.data() + halfSize, halfSize);
}

void SodiumNonce::increment()
{
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  auto* ptr = reinterpret_cast<uint32_t*>(value.data());
  uint32_t count = htonl(*ptr);
  *ptr = ntohl(++count);
}

#else
void SodiumNonce::init()
{
}

void SodiumNonce::merge(const SodiumNonce& lower, const SodiumNonce& higher)
{
}

void SodiumNonce::increment()
{
}

std::string sodEncryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
{
  return std::string(msg);
}
std::string sodDecryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
{
  return std::string(msg);
}

string newKey(bool base64Encoded)
{
  return "\"plaintext\"";
}

bool sodIsValidKey(const std::string& key)
{
  return true;
}

#endif

#include <cinttypes>

namespace anonpdns {
static char B64Decode1(char cInChar)
{
  // The incoming character will be A-Z, a-z, 0-9, +, /, or =.
  // The idea is to quickly determine which grouping the
  // letter belongs to and return the associated value
  // without having to search the global encoding string
  // (the value we're looking for would be the resulting
  // index into that string).
  //
  // To do that, we'll play some tricks...
  unsigned char iIndex = '\0';
  switch ( cInChar ) {
  case '+':
    iIndex = 62;
    break;

  case '/':
    iIndex = 63;
    break;

  case '=':
    iIndex = 0;
    break;

  default:
    // Must be 'A'-'Z', 'a'-'z', '0'-'9', or an error...
    //
    // Numerically, small letters are "greater" in value than
    // capital letters and numerals (ASCII value), and capital
    // letters are "greater" than numerals (again, ASCII value),
    // so we check for numerals first, then capital letters,
    // and finally small letters.
    iIndex = '9' - cInChar;
    if ( iIndex > 0x3F ) {
      // Not from '0' to '9'...
      iIndex = 'Z' - cInChar;
      if ( iIndex > 0x3F ) {
        // Not from 'A' to 'Z'...
        iIndex = 'z' - cInChar;
        if ( iIndex > 0x3F ) {
          // Invalid character...cannot
          // decode!
          iIndex = 0x80; // set the high bit
        } // if
        else {
          // From 'a' to 'z'
          iIndex = (('z' - iIndex) - 'a') + 26;
        } // else
      } // if
      else {
        // From 'A' to 'Z'
        iIndex = ('Z' - iIndex) - 'A';
      } // else
    } // if
    else {
      // Adjust the index...
      iIndex = (('9' - iIndex) - '0') + 52;
    } // else
    break;

  } // switch

  return iIndex;
}

static inline char B64Encode1(unsigned char uc)
{
  if (uc < 26)
    {
      return 'A'+uc;
    }
  if (uc < 52)
    {
      return 'a'+(uc-26);
    }
  if (uc < 62)
    {
      return '0'+(uc-52);
    }
  if (uc == 62)
    {
      return '+';
    }
  return '/';
};



}
using namespace anonpdns;

template<typename Container> int B64Decode(const std::string& strInput, Container& strOutput)
{
  // Set up a decoding buffer
  long cBuf = 0;
  char* pBuf = (char*)&cBuf;

  // Decoding management...
  int iBitGroup = 0, iInNum = 0;

  // While there are characters to process...
  //
  // We'll decode characters in blocks of 4, as
  // there are 4 groups of 6 bits in 3 bytes. The
  // incoming Base64 character is first decoded, and
  // then it is inserted into the decode buffer
  // (with any relevant shifting, as required).
  // Later, after all 3 bytes have been reconstituted,
  // we assign them to the output string, ultimately
  // to be returned as the original message.
  int iInSize = strInput.size();
  unsigned char cChar = '\0';
  uint8_t pad = 0;
  while ( iInNum < iInSize ) {
    // Fill the decode buffer with 4 groups of 6 bits
    cBuf = 0; // clear
    pad = 0;
    for ( iBitGroup = 0; iBitGroup < 4; ++iBitGroup ) {
      if ( iInNum < iInSize ) {
        // Decode a character
       if(strInput.at(iInNum)=='=')
         pad++;
        while(isspace(strInput.at(iInNum)))
          iInNum++;
        cChar = B64Decode1(strInput.at(iInNum++));

      } // if
      else {
        // Decode a padded zero
        cChar = '\0';
      } // else

      // Check for valid decode
      if ( cChar > 0x7F )
        return -1;

      // Adjust the bits
      switch ( iBitGroup ) {
      case 0:
        // The first group is copied into
        // the least significant 6 bits of
        // the decode buffer...these 6 bits
        // will eventually shift over to be
        // the most significant bits of the
        // third byte.
        cBuf = cBuf | cChar;
        break;

      default:
        // For groupings 1-3, simply shift
        // the bits in the decode buffer over
        // by 6 and insert the 6 from the
        // current decode character.
        cBuf = (cBuf << 6) | cChar;
        break;

      } // switch
    } // for

    // Interpret the resulting 3 bytes...note there
    // may have been padding, so those padded bytes
    // are actually ignored.
#if BYTE_ORDER == BIG_ENDIAN
    strOutput.push_back(pBuf[sizeof(long)-3]);
    strOutput.push_back(pBuf[sizeof(long)-2]);
    strOutput.push_back(pBuf[sizeof(long)-1]);
#else
    strOutput.push_back(pBuf[2]);
    strOutput.push_back(pBuf[1]);
    strOutput.push_back(pBuf[0]);
#endif
  } // while
  if(pad)
    strOutput.resize(strOutput.size()-pad);

  return 1;
}

template int B64Decode<std::vector<uint8_t>>(const std::string& strInput, std::vector<uint8_t>& strOutput);
template int B64Decode<PacketBuffer>(const std::string& strInput, PacketBuffer& strOutput);
template int B64Decode<std::string>(const std::string& strInput, std::string& strOutput);

/*
www.kbcafe.com
Copyright 2001-2002 Randy Charles Morin
The Encode static method takes an array of 8-bit values and returns a base-64 stream.
*/


std::string Base64Encode (const std::string& vby)
{
  std::string retval;
  if (vby.size () == 0)
    {
      return retval;
    };
  for (unsigned int i = 0; i < vby.size (); i += 3)
    {
      unsigned char by1 = 0, by2 = 0, by3 = 0;
      by1 = vby[i];
      if (i + 1 < vby.size ())
        {
          by2 = vby[i + 1];
        };
      if (i + 2 < vby.size ())
        {
          by3 = vby[i + 2];
        }
      unsigned char by4 = 0, by5 = 0, by6 = 0, by7 = 0;
      by4 = by1 >> 2;
      by5 = ((by1 & 0x3) << 4) | (by2 >> 4);
      by6 = ((by2 & 0xf) << 2) | (by3 >> 6);
      by7 = by3 & 0x3f;
      retval += B64Encode1 (by4);
      retval += B64Encode1 (by5);
      if (i + 1 < vby.size ())
        {
          retval += B64Encode1 (by6);
        }
      else
        {
          retval += "=";
        };
      if (i + 2 < vby.size ())
        {
          retval += B64Encode1 (by7);
        }
      else
        {
          retval += "=";
        };
      /*      if ((i % (76 / 4 * 3)) == 0)
        {
          retval += "\r\n";
          }*/
    };
  return retval;
};

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#include <iostream>
23	#include <arpa/inet.h>
24
25	#include "namespaces.hh"
26	#include "noinitvector.hh"
27	#include "misc.hh"
28	#include "base64.hh"
29	#include "sodcrypto.hh"
30
31	#ifdef HAVE_LIBSODIUM
32
33	string newKey(bool base64Encoded)
34	{	575✔
35	std::string key;	575✔
36	key.resize(crypto_secretbox_KEYBYTES);	575✔
37
38	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
39	randombytes_buf(reinterpret_cast<unsigned char*>(key.data()), key.size());	575✔
40
41	if (!base64Encoded) {	575!
42	return key;	575✔
43	}	575✔
44	return "\"" + Base64Encode(key) + "\"";
45	}	575✔
46
47	bool sodIsValidKey(const std::string& key)
48	{	781✔
49	return key.size() == crypto_secretbox_KEYBYTES;	781✔
50	}	781✔
51
52	std::string sodEncryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
53	{	276✔
54	if (!sodIsValidKey(key)) {	276!
55	throw std::runtime_error("Invalid encryption key of size " + std::to_string(key.size()) + " (" + std::to_string(crypto_secretbox_KEYBYTES) + " expected), use setKey() to set a valid key");
56	}
57
58	std::string ciphertext;	276✔
59	ciphertext.resize(msg.length() + crypto_secretbox_MACBYTES);	276✔
60	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
61	crypto_secretbox_easy(reinterpret_cast<unsigned char*>(ciphertext.data()),	276✔
62	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
63	reinterpret_cast<const unsigned char*>(msg.data()),	276✔
64	msg.length(),	276✔
65	nonce.value.data(),	276✔
66	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
67	reinterpret_cast<const unsigned char*>(key.data()));	276✔
68
69	if (incrementNonce) {	276✔
70	nonce.increment();	224✔
71	}	224✔
72
73	return ciphertext;	276✔
74	}	276✔
75
76	std::string sodDecryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
77	{	276✔
78	std::string decrypted;	276✔
79
80	if (msg.length() < crypto_secretbox_MACBYTES) {	276!
81	throw std::runtime_error("Could not decrypt message of size " + std::to_string(msg.length()));
82	}
83
84	if (!sodIsValidKey(key)) {	276!
85	throw std::runtime_error("Invalid decryption key of size " + std::to_string(key.size()) + ", use setKey() to set a valid key");
86	}
87
88	decrypted.resize(msg.length() - crypto_secretbox_MACBYTES);	276✔
89
90	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
91	if (crypto_secretbox_open_easy(reinterpret_cast<unsigned char*>(decrypted.data()),	276!
92	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
93	reinterpret_cast<const unsigned char*>(msg.data()),	276✔
94	msg.length(),	276✔
95	nonce.value.data(),	276✔
96	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
97	reinterpret_cast<const unsigned char*>(key.data())) != 0) {	276✔
98	throw std::runtime_error("Could not decrypt message, please check that the key configured with setKey() is correct");
99	}
100
101	if (incrementNonce) {	276✔
102	nonce.increment();	224✔
103	}	224✔
104
105	return decrypted;	276✔
106	}	276✔
107
108	void SodiumNonce::init()
109	{	278✔
110	randombytes_buf(value.data(), value.size());	278✔
111	}	278✔
112
113	void SodiumNonce::merge(const SodiumNonce& lower, const SodiumNonce& higher)
114	{	448✔
115	constexpr size_t halfSize = std::tuple_size<decltype(value)>{} / 2;	448✔
116	memcpy(value.data(), lower.value.data(), halfSize);	448✔
117	memcpy(value.data() + halfSize, higher.value.data() + halfSize, halfSize);	448✔
118	}	448✔
119
120	void SodiumNonce::increment()
121	{	448✔
122	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
123	auto* ptr = reinterpret_cast<uint32_t*>(value.data());	448✔
124	uint32_t count = htonl(*ptr);	448✔
125	*ptr = ntohl(++count);	448✔
126	}	448✔
127
128	#else
129	void SodiumNonce::init()
130	{
131	}
132
133	void SodiumNonce::merge(const SodiumNonce& lower, const SodiumNonce& higher)
134	{
135	}
136
137	void SodiumNonce::increment()
138	{
139	}
140
141	std::string sodEncryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
142	{
143	return std::string(msg);
144	}
145	std::string sodDecryptSym(const std::string_view& msg, const std::string& key, SodiumNonce& nonce, bool incrementNonce)
146	{
147	return std::string(msg);
148	}
149
150	string newKey(bool base64Encoded)
151	{
152	return "\"plaintext\"";
153	}
154
155	bool sodIsValidKey(const std::string& key)
156	{
157	return true;
158	}
159
160	#endif
161
162	#include <cinttypes>
163
164	namespace anonpdns {
165	static char B64Decode1(char cInChar)
166	{	33,358✔
167	// The incoming character will be A-Z, a-z, 0-9, +, /, or =.
168	// The idea is to quickly determine which grouping the
169	// letter belongs to and return the associated value
170	// without having to search the global encoding string
171	// (the value we're looking for would be the resulting
172	// index into that string).
173	//
174	// To do that, we'll play some tricks...
175	unsigned char iIndex = '\0';	33,358✔
176	switch ( cInChar ) {	33,358✔
177	case '+':	146✔
178	iIndex = 62;	146✔
179	break;	146✔
180
181	case '/':	99✔
182	iIndex = 63;	99✔
183	break;	99✔
184
185	case '=':	840✔
186	iIndex = 0;	840✔
187	break;	840✔
188
189	default:	32,273✔
190	// Must be 'A'-'Z', 'a'-'z', '0'-'9', or an error...
191	//
192	// Numerically, small letters are "greater" in value than
193	// capital letters and numerals (ASCII value), and capital
194	// letters are "greater" than numerals (again, ASCII value),
195	// so we check for numerals first, then capital letters,
196	// and finally small letters.
197	iIndex = '9' - cInChar;	32,273✔
198	if ( iIndex > 0x3F ) {	32,273✔
199	// Not from '0' to '9'...
200	iIndex = 'Z' - cInChar;	27,876✔
201	if ( iIndex > 0x3F ) {	27,876✔
202	// Not from 'A' to 'Z'...
203	iIndex = 'z' - cInChar;	11,521✔
204	if ( iIndex > 0x3F ) {	11,521✔
205	// Invalid character...cannot
206	// decode!
207	iIndex = 0x80; // set the high bit	2✔
208	} // if	2✔
209	else {	11,519✔
210	// From 'a' to 'z'
211	iIndex = (('z' - iIndex) - 'a') + 26;	11,519✔
212	} // else	11,519✔
213	} // if	11,521✔
214	else {	16,355✔
215	// From 'A' to 'Z'
216	iIndex = ('Z' - iIndex) - 'A';	16,355✔
217	} // else	16,355✔
218	} // if	27,876✔
219	else {	4,397✔
220	// Adjust the index...
221	iIndex = (('9' - iIndex) - '0') + 52;	4,397✔
222	} // else	4,397✔
223	break;	32,273✔
224
225	} // switch	33,358✔
226
227	return iIndex;	33,358✔
228	}	33,358✔
229
230	static inline char B64Encode1(unsigned char uc)
231	{	1,719✔
232	if (uc < 26)	1,719✔
233	{	922✔
234	return 'A'+uc;	922✔
235	}	922✔
236	if (uc < 52)	797✔
237	{	581✔
238	return 'a'+(uc-26);	581✔
239	}	581✔
240	if (uc < 62)	216✔
241	{	214✔
242	return '0'+(uc-52);	214✔
243	}	214✔
244	if (uc == 62)	2!
UNCOV 245	{	×
UNCOV 246	return '+';	×
UNCOV 247	}	×
248	return '/';	2✔
249	};	2✔
250
251
252
253	}
254	using namespace anonpdns;
255
256	template<typename Container> int B64Decode(const std::string& strInput, Container& strOutput)
257	{	690✔
258	// Set up a decoding buffer
259	long cBuf = 0;	690✔
260	char* pBuf = (char*)&cBuf;	690✔
261
262	// Decoding management...
263	int iBitGroup = 0, iInNum = 0;	690✔
264
265	// While there are characters to process...
266	//
267	// We'll decode characters in blocks of 4, as
268	// there are 4 groups of 6 bits in 3 bytes. The
269	// incoming Base64 character is first decoded, and
270	// then it is inserted into the decode buffer
271	// (with any relevant shifting, as required).
272	// Later, after all 3 bytes have been reconstituted,
273	// we assign them to the output string, ultimately
274	// to be returned as the original message.
275	int iInSize = strInput.size();	690✔
276	unsigned char cChar = '\0';	690✔
277	uint8_t pad = 0;	690✔
278	while ( iInNum < iInSize ) {	9,029!
279	// Fill the decode buffer with 4 groups of 6 bits
280	cBuf = 0; // clear	8,341✔
281	pad = 0;	8,341✔
282	for ( iBitGroup = 0; iBitGroup < 4; ++iBitGroup ) {	41,701!
283	if ( iInNum < iInSize ) {	33,362!
284	// Decode a character
285	if(strInput.at(iInNum)=='=')	33,358!
286	pad++;	840✔
287	while(isspace(strInput.at(iInNum)))	33,358!
288	iInNum++;	×
289	cChar = B64Decode1(strInput.at(iInNum++));	33,358✔
290
291	} // if	33,358✔
292	else {	4✔
293	// Decode a padded zero
294	cChar = '\0';	4✔
295	} // else	4✔
296
297	// Check for valid decode
298	if ( cChar > 0x7F )	33,362!
299	return -1;	2✔
300
301	// Adjust the bits
302	switch ( iBitGroup ) {	33,360✔
303	case 0:	8,341!
304	// The first group is copied into
305	// the least significant 6 bits of
306	// the decode buffer...these 6 bits
307	// will eventually shift over to be
308	// the most significant bits of the
309	// third byte.
310	cBuf = cBuf \| cChar;	8,341✔
311	break;	8,341✔
312
313	default:	25,019!
314	// For groupings 1-3, simply shift
315	// the bits in the decode buffer over
316	// by 6 and insert the 6 from the
317	// current decode character.
318	cBuf = (cBuf << 6) \| cChar;	25,019✔
319	break;	25,019✔
320
321	} // switch	33,360✔
322	} // for	33,360✔
323
324	// Interpret the resulting 3 bytes...note there
325	// may have been padding, so those padded bytes
326	// are actually ignored.
327	#if BYTE_ORDER == BIG_ENDIAN
328	strOutput.push_back(pBuf[sizeof(long)-3]);
329	strOutput.push_back(pBuf[sizeof(long)-2]);
330	strOutput.push_back(pBuf[sizeof(long)-1]);
331	#else
332	strOutput.push_back(pBuf[2]);	8,339✔
333	strOutput.push_back(pBuf[1]);	8,339✔
334	strOutput.push_back(pBuf[0]);	8,339✔
335	#endif	8,339✔
336	} // while	8,339✔
337	if(pad)	688!
338	strOutput.resize(strOutput.size()-pad);	591✔
339
340	return 1;	688✔
341	}	690✔
342
343	template int B64Decode<std::vector<uint8_t>>(const std::string& strInput, std::vector<uint8_t>& strOutput);
344	template int B64Decode<PacketBuffer>(const std::string& strInput, PacketBuffer& strOutput);
345	template int B64Decode<std::string>(const std::string& strInput, std::string& strOutput);
346
347	/*
348	www.kbcafe.com
349	Copyright 2001-2002 Randy Charles Morin
350	The Encode static method takes an array of 8-bit values and returns a base-64 stream.
351	*/
352
353
354	std::string Base64Encode (const std::string& vby)
355	{	75✔
356	std::string retval;	75✔
357	if (vby.size () == 0)	75✔
358	{	2✔
359	return retval;	2✔
360	};	73✔
361	for (unsigned int i = 0; i < vby.size (); i += 3)	522✔
362	{	449✔
363	unsigned char by1 = 0, by2 = 0, by3 = 0;	449✔
364	by1 = vby[i];	449✔
365	if (i + 1 < vby.size ())	449✔
366	{	423✔
367	by2 = vby[i + 1];	423✔
368	};	423✔
369	if (i + 2 < vby.size ())	449✔
370	{	398✔
371	by3 = vby[i + 2];	398✔
372	}	398✔
373	unsigned char by4 = 0, by5 = 0, by6 = 0, by7 = 0;	449✔
374	by4 = by1 >> 2;	449✔
375	by5 = ((by1 & 0x3) << 4) \| (by2 >> 4);	449✔
376	by6 = ((by2 & 0xf) << 2) \| (by3 >> 6);	449✔
377	by7 = by3 & 0x3f;	449✔
378	retval += B64Encode1 (by4);	449✔
379	retval += B64Encode1 (by5);	449✔
380	if (i + 1 < vby.size ())	449✔
381	{	423✔
382	retval += B64Encode1 (by6);	423✔
383	}	423✔
384	else	26✔
385	{	26✔
386	retval += "=";	26✔
387	};	26✔
388	if (i + 2 < vby.size ())	449✔
389	{	398✔
390	retval += B64Encode1 (by7);	398✔
391	}	398✔
392	else	51✔
393	{	51✔
394	retval += "=";	51✔
395	};	51✔
396	/* if ((i % (76 / 4 * 3)) == 0)
397	{
398	retval += "\r\n";
399	}*/
400	};	449✔
401	return retval;	73✔
402	};	75✔

PowerDNS / pdns / 7084950926

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous