/src/botan/src/lib/pubkey/pem/pem.cpp

Source
/*
* PEM Encoding/Decoding
* (C) 1999-2007 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/pem.h>

#include <botan/base64.h>
#include <botan/data_src.h>
#include <botan/exceptn.h>
#include <botan/internal/fmt.h>

namespace Botan::PEM_Code {

namespace {

std::string linewrap(size_t width, std::string_view in) {
   std::string out;
   for(size_t i = 0; i != in.size(); ++i) {
      if(i > 0 && i % width == 0) {
         out.push_back('\n');
      }
      out.push_back(in[i]);
   }
   if(!out.empty() && out[out.size() - 1] != '\n') {
      out.push_back('\n');
   }

   return out;
}

}  // namespace

/*
* PEM encode BER/DER-encoded objects
*/
std::string encode(const uint8_t der[], size_t length, std::string_view label, size_t width) {
   const std::string PEM_HEADER = fmt("-----BEGIN {}-----\n", label);
   const std::string PEM_TRAILER = fmt("-----END {}-----\n", label);

   return (PEM_HEADER + linewrap(width, base64_encode(der, length)) + PEM_TRAILER);
}

/*
* Decode PEM down to raw BER/DER
*/
secure_vector<uint8_t> decode_check_label(DataSource& source, std::string_view label_want) {
   std::string label_got;
   secure_vector<uint8_t> ber = decode(source, label_got);
   if(label_got != label_want) {
      throw Decoding_Error(fmt("PEM: Label mismatch, wanted '{}' got '{}'", label_want, label_got));
   }

   return ber;
}

/*
* Decode PEM down to raw BER/DER
*/
secure_vector<uint8_t> decode(DataSource& source, std::string& label) {
   const size_t RANDOM_CHAR_LIMIT = 8;

   label.clear();

   const std::string PEM_HEADER1 = "-----BEGIN ";
   const std::string PEM_HEADER2 = "-----";
   size_t position = 0;

   while(position != PEM_HEADER1.length()) {
      auto b = source.read_byte();

      if(!b) {
         throw Decoding_Error("PEM: No PEM header found");
      }
      if(static_cast<char>(*b) == PEM_HEADER1[position]) {
         ++position;
      } else if(position >= RANDOM_CHAR_LIMIT) {
         throw Decoding_Error("PEM: Malformed PEM header");
      } else {
         position = 0;
      }
   }
   position = 0;
   while(position != PEM_HEADER2.length()) {
      auto b = source.read_byte();

      if(!b) {
         throw Decoding_Error("PEM: No PEM header found");
      }
      if(static_cast<char>(*b) == PEM_HEADER2[position]) {
         ++position;
      } else if(position > 0) {
         throw Decoding_Error("PEM: Malformed PEM header");
      }

      if(position == 0) {
         label += static_cast<char>(*b);
      }
   }

   std::vector<char> b64;

   const std::string PEM_TRAILER = fmt("-----END {}-----", label);
   position = 0;
   while(position != PEM_TRAILER.length()) {
      auto b = source.read_byte();

      if(!b) {
         throw Decoding_Error("PEM: No PEM trailer found");
      }
      if(static_cast<char>(*b) == PEM_TRAILER[position]) {
         ++position;
      } else if(position > 0) {
         throw Decoding_Error("PEM: Malformed PEM trailer");
      }

      if(position == 0) {
         b64.push_back(*b);
      }
   }

   return base64_decode(b64.data(), b64.size());
}

secure_vector<uint8_t> decode_check_label(std::string_view pem, std::string_view label_want) {
   DataSource_Memory src(pem);
   return decode_check_label(src, label_want);
}

secure_vector<uint8_t> decode(std::string_view pem, std::string& label) {
   DataSource_Memory src(pem);
   return decode(src, label);
}

/*
* Search for a PEM signature
*/
bool matches(DataSource& source, std::string_view extra, size_t search_range) {
   const std::string PEM_HEADER = fmt("-----BEGIN {}", extra);

   secure_vector<uint8_t> search_buf(search_range);
   const size_t got = source.peek(search_buf.data(), search_buf.size(), 0);

   if(got < PEM_HEADER.length()) {
      return false;
   }

   size_t index = 0;

   for(size_t j = 0; j != got; ++j) {
      if(static_cast<char>(search_buf[j]) == PEM_HEADER[index]) {
         ++index;
      } else {
         index = 0;
      }

      if(index == PEM_HEADER.size()) {
         return true;
      }
   }

   return false;
}

}  // namespace Botan::PEM_Code

Line	Count	Source
1		/*
2		* PEM Encoding/Decoding
3		* (C) 1999-2007 Jack Lloyd
4		*
5		* Botan is released under the Simplified BSD License (see license.txt)
6		*/
7
8		#include <botan/pem.h>
9
10		#include <botan/base64.h>
11		#include <botan/data_src.h>
12		#include <botan/exceptn.h>
13		#include <botan/internal/fmt.h>
14
15		namespace Botan::PEM_Code {
16
17		namespace {
18
19	0	std::string linewrap(size_t width, std::string_view in) {
20	0	std::string out;
21	0	for(size_t i = 0; i != in.size(); ++i) {
22	0	if(i > 0 && i % width == 0) {
23	0	out.push_back('\n');
24	0	}
25	0	out.push_back(in[i]);
26	0	}
27	0	if(!out.empty() && out[out.size() - 1] != '\n') {
28	0	out.push_back('\n');
29	0	}
30
31	0	return out;
32	0	}
33
34		} // namespace
35
36		/*
37		* PEM encode BER/DER-encoded objects
38		*/
39	0	std::string encode(const uint8_t der[], size_t length, std::string_view label, size_t width) {
40	0	const std::string PEM_HEADER = fmt("-----BEGIN {}-----\n", label);
41	0	const std::string PEM_TRAILER = fmt("-----END {}-----\n", label);
42
43	0	return (PEM_HEADER + linewrap(width, base64_encode(der, length)) + PEM_TRAILER);
44	0	}
45
46		/*
47		* Decode PEM down to raw BER/DER
48		*/
49	0	secure_vector<uint8_t> decode_check_label(DataSource& source, std::string_view label_want) {
50	0	std::string label_got;
51	0	secure_vector<uint8_t> ber = decode(source, label_got);
52	0	if(label_got != label_want) {
53	0	throw Decoding_Error(fmt("PEM: Label mismatch, wanted '{}' got '{}'", label_want, label_got));
54	0	}
55
56	0	return ber;
57	0	}
58
59		/*
60		* Decode PEM down to raw BER/DER
61		*/
62	0	secure_vector<uint8_t> decode(DataSource& source, std::string& label) {
63	0	const size_t RANDOM_CHAR_LIMIT = 8;
64
65	0	label.clear();
66
67	0	const std::string PEM_HEADER1 = "-----BEGIN ";
68	0	const std::string PEM_HEADER2 = "-----";
69	0	size_t position = 0;
70
71	0	while(position != PEM_HEADER1.length()) {
72	0	auto b = source.read_byte();
73
74	0	if(!b) {
75	0	throw Decoding_Error("PEM: No PEM header found");
76	0	}
77	0	if(static_cast<char>(*b) == PEM_HEADER1[position]) {
78	0	++position;
79	0	} else if(position >= RANDOM_CHAR_LIMIT) {
80	0	throw Decoding_Error("PEM: Malformed PEM header");
81	0	} else {
82	0	position = 0;
83	0	}
84	0	}
85	0	position = 0;
86	0	while(position != PEM_HEADER2.length()) {
87	0	auto b = source.read_byte();
88
89	0	if(!b) {
90	0	throw Decoding_Error("PEM: No PEM header found");
91	0	}
92	0	if(static_cast<char>(*b) == PEM_HEADER2[position]) {
93	0	++position;
94	0	} else if(position > 0) {
95	0	throw Decoding_Error("PEM: Malformed PEM header");
96	0	}
97
98	0	if(position == 0) {
99	0	label += static_cast<char>(*b);
100	0	}
101	0	}
102
103	0	std::vector<char> b64;
104
105	0	const std::string PEM_TRAILER = fmt("-----END {}-----", label);
106	0	position = 0;
107	0	while(position != PEM_TRAILER.length()) {
108	0	auto b = source.read_byte();
109
110	0	if(!b) {
111	0	throw Decoding_Error("PEM: No PEM trailer found");
112	0	}
113	0	if(static_cast<char>(*b) == PEM_TRAILER[position]) {
114	0	++position;
115	0	} else if(position > 0) {
116	0	throw Decoding_Error("PEM: Malformed PEM trailer");
117	0	}
118
119	0	if(position == 0) {
120	0	b64.push_back(*b);
121	0	}
122	0	}
123
124	0	return base64_decode(b64.data(), b64.size());
125	0	}
126
127	0	secure_vector<uint8_t> decode_check_label(std::string_view pem, std::string_view label_want) {
128	0	DataSource_Memory src(pem);
129	0	return decode_check_label(src, label_want);
130	0	}
131
132	0	secure_vector<uint8_t> decode(std::string_view pem, std::string& label) {
133	0	DataSource_Memory src(pem);
134	0	return decode(src, label);
135	0	}
136
137		/*
138		* Search for a PEM signature
139		*/
140	0	bool matches(DataSource& source, std::string_view extra, size_t search_range) {
141	0	const std::string PEM_HEADER = fmt("-----BEGIN {}", extra);
142
143	0	secure_vector<uint8_t> search_buf(search_range);
144	0	const size_t got = source.peek(search_buf.data(), search_buf.size(), 0);
145
146	0	if(got < PEM_HEADER.length()) {
147	0	return false;
148	0	}
149
150	0	size_t index = 0;
151
152	0	for(size_t j = 0; j != got; ++j) {
153	0	if(static_cast<char>(search_buf[j]) == PEM_HEADER[index]) {
154	0	++index;
155	0	} else {
156	0	index = 0;
157	0	}
158
159	0	if(index == PEM_HEADER.size()) {
160	0	return true;
161	0	}
162	0	}
163
164	0	return false;
165	0	}
166
167		} // namespace Botan::PEM_Code

Coverage Report

Created: 2026-03-31 07:01