bool PEM_IsEncrypted(SecByteBlock& sb)
{
SecByteBlock::iterator it = search(sb.begin(), sb.end(), SBB_PROC_TYPE.begin(), SBB_PROC_TYPE.end());
if (it == sb.end()) return false;
it = search(it + SBB_PROC_TYPE.size(), sb.end(), SBB_ENCRYPTED.begin(), SBB_ENCRYPTED.end());
return it != sb.end();
}
void
CertificateExtension::decode(CryptoPP::BufferedTransformation& in)
{
using namespace CryptoPP;
// Extension ::= SEQUENCE {
// extnID OBJECT IDENTIFIER,
// critical BOOLEAN DEFAULT FALSE,
// extnValue OCTET STRING }
BERSequenceDecoder extension(in);
{
m_extensionId.decode(extension);
BERDecodeUnsigned(extension, m_isCritical, BOOLEAN);
// the extra copy operation can be optimized, but not trivial,
// since the length is not known in advance
SecByteBlock tmpBlock;
BERDecodeOctetString(extension, tmpBlock);
m_extensionValue.assign(tmpBlock.begin(), tmpBlock.end());
}
extension.MessageEnd();
}
void PEM_NextObject(BufferedTransformation& src, BufferedTransformation& dest, bool trimTrailing)
{
if(!src.AnyRetrievable())
return;
// We have four things to find:
// 1. -----BEGIN (the leading begin)
// 2. ----- (the trailing dashes)
// 3. -----END (the leading end)
// 4. ----- (the trailing dashes)
// Once we parse something that purports to be PEM encoded, another routine
// will have to look for something particular, like a RSA key. We *will*
// inadvertently parse garbage, like -----BEGIN FOO BAR-----. It will
// be caught later when a PEM_Load routine is called.
static const size_t BAD_IDX = PEM_INVALID;
// We use iterators for the search. However, an interator is invalidated
// after each insert that grows the container. So we save indexes
// from begin() to speed up searching. On each iteration, we simply
// reinitialize them.
SecByteBlock::const_iterator it;
size_t idx1 = BAD_IDX, idx2 = BAD_IDX, idx3 = BAD_IDX, idx4 = BAD_IDX;
// The idea is to read chunks in case there are multiple keys or
// paramters in a BufferedTransformation. So we use CopyTo to
// extract what we are interested in. We don't take anything
// out of the BufferedTransformation (yet).
// We also use indexes because the iterator will be invalidated
// when we append to the ByteQueue. Even though the iterator
// is invalid, `accum.begin() + index` will be valid.
// Reading 8 or 10 lines at a time is an optimization from testing
// against cacerts.pem. The file has 153 certs, so its a good test.
// +2 to allow for CR + LF line endings. There's no guarantee a line
// will be present, or it will be RFC1421_LINE_BREAK in size.
static const size_t READ_SIZE = (RFC1421_LINE_BREAK + 1) * 10;
static const size_t REWIND = max(SBB_PEM_BEGIN.size(), SBB_PEM_END.size()) + 2;
SecByteBlock accum;
size_t idx = 0, next = 0;
size_t available = src.MaxRetrievable();
while(available)
{
// How much can we read?
const size_t size = std::min(available, READ_SIZE);
// Ideally, we would only scan the line we are reading. However,
// we need to rewind a bit in case a token spans the previous
// block and the block we are reading. But we can't rewind
// into a previous index. Once we find an index, the variable
// next is set to it. Hence the reason for the max()
if(idx > REWIND)
{
const size_t x = idx - REWIND;
next = max(next, x);
}
#if 0
// Next should be less than index by 10 or so
std::cout << " Index: " << idx << std::endl;
std::cout << " Next: " << next << std::endl;
#endif
// We need a temp queue to use CopyRangeTo. We have to use it
// because there's no Peek that allows us to peek a range.
ByteQueue tq;
src.CopyRangeTo(tq, static_cast<lword>(idx), static_cast<lword>(size));
const size_t offset = accum.size();
accum.Grow(offset + size);
tq.Get(accum.data() + offset, size);
// Adjust sizes
idx += size;
available -= size;
// Locate '-----BEGIN'
if(idx1 == BAD_IDX)
{
it = search(accum.begin() + next, accum.end(), SBB_PEM_BEGIN.begin(), SBB_PEM_BEGIN.end());
if(it == accum.end())
continue;
idx1 = it - accum.begin();
next = idx1 + SBB_PEM_BEGIN.size();
}
// Locate '-----'
if(idx2 == BAD_IDX && idx1 != BAD_IDX)
{
it = search(accum.begin() + next, accum.end(), SBB_PEM_TAIL.begin(), SBB_PEM_TAIL.end());
if(it == accum.end())
continue;
idx2 = it - accum.begin();
next = idx2 + SBB_PEM_TAIL.size();
}
// Locate '-----END'
if(idx3 == BAD_IDX && idx2 != BAD_IDX)
{
it = search(accum.begin() + next, accum.end(), SBB_PEM_END.begin(), SBB_PEM_END.end());
if(it == accum.end())
continue;
idx3 = it - accum.begin();
next = idx3 + SBB_PEM_END.size();
}
// Locate '-----'
if(idx4 == BAD_IDX && idx3 != BAD_IDX)
{
it = search(accum.begin() + next, accum.end(), SBB_PEM_TAIL.begin(), SBB_PEM_TAIL.end());
if(it == accum.end())
continue;
idx4 = it - accum.begin();
next = idx4 + SBB_PEM_TAIL.size();
}
}
// Did we find `-----BEGIN XXX-----` (RFC 1421 calls this pre-encapsulated boundary)?
if(idx1 == BAD_IDX || idx2 == BAD_IDX)
throw InvalidDataFormat("PEM_NextObject: could not locate boundary header");
// Did we find `-----END XXX-----` (RFC 1421 calls this post-encapsulated boundary)?
if(idx3 == BAD_IDX || idx4 == BAD_IDX)
throw InvalidDataFormat("PEM_NextObject: could not locate boundary footer");
// *IF* the trailing '-----' occurred in the last 5 bytes in accum, then we might miss the
// End of Line. We need to peek 2 more bytes if available and append them to accum.
if(available >= 2)
{
ByteQueue tq;
src.CopyRangeTo(tq, static_cast<lword>(idx), static_cast<lword>(2));
const size_t offset = accum.size();
accum.Grow(offset + 2);
tq.Get(accum.data() + offset, 2);
}
else if(available == 1)
{
ByteQueue tq;
src.CopyRangeTo(tq, static_cast<lword>(idx), static_cast<lword>(1));
const size_t offset = accum.size();
accum.Grow(offset + 1);
tq.Get(accum.data() + offset, 1);
}
// Final book keeping
const byte* ptr = accum.begin() + idx1;
const size_t used = idx4 + SBB_PEM_TAIL.size();
const size_t len = used - idx1;
// Include one CR/LF if its available in the accumulator
next = idx1 + len;
size_t adjust = 0;
if(next < accum.size())
{
byte c1 = accum[next];
byte c2 = 0;
if(next + 1 < accum.size())
c2 = accum[next + 1];
// Longest match first
if(c1 == '\r' && c2 == '\n')
adjust = 2;
else if(c1 == '\r' || c1 == '\n')
adjust = 1;
}
dest.Put(ptr, len + adjust);
dest.MessageEnd();
src.Skip(used + adjust);
if(trimTrailing)
{
while (src.AnyRetrievable())
{
byte b;
src.Peek(b);
if(!isspace(b)) break;
src.Skip(1);
}
}
}
PEM_Type PEM_GetType(const SecByteBlock& sb)
{
SecByteBlock::const_iterator it;
it = Search(sb, SBB_PUBLIC_BEGIN);
if(it != sb.end())
return PEM_PUBLIC_KEY;
// RSA key types
it = Search(sb, SBB_RSA_PUBLIC_BEGIN);
if(it != sb.end())
return PEM_RSA_PUBLIC_KEY;
it = Search(sb, SBB_RSA_PRIVATE_BEGIN);
if(it != sb.end())
{
it = Search(sb, SBB_PROC_TYPE_ENC);
if(it != sb.end())
return PEM_RSA_ENC_PRIVATE_KEY;
return PEM_RSA_PRIVATE_KEY;
}
// DSA key types
it = Search(sb, SBB_DSA_PUBLIC_BEGIN);
if(it != sb.end())
return PEM_DSA_PUBLIC_KEY;
it = Search(sb, SBB_DSA_PRIVATE_BEGIN);
if(it != sb.end())
{
it = Search(sb, SBB_PROC_TYPE_ENC);
if(it != sb.end())
return PEM_DSA_ENC_PRIVATE_KEY;
return PEM_DSA_PRIVATE_KEY;
}
// EC key types
it = Search(sb, SBB_EC_PUBLIC_BEGIN);
if(it != sb.end())
return PEM_EC_PUBLIC_KEY;
it = Search(sb, SBB_ECDSA_PUBLIC_BEGIN);
if(it != sb.end())
return PEM_ECDSA_PUBLIC_KEY;
it = Search(sb, SBB_EC_PRIVATE_BEGIN);
if(it != sb.end())
{
it = Search(sb, SBB_PROC_TYPE_ENC);
if(it != sb.end())
return PEM_EC_ENC_PRIVATE_KEY;
return PEM_EC_PRIVATE_KEY;
}
// EC Parameters
it = Search(sb, SBB_EC_PARAMETERS_BEGIN);
if(it != sb.end())
return PEM_EC_PARAMETERS;
// DH Parameters
it = Search(sb, SBB_DH_PARAMETERS_BEGIN);
if(it != sb.end())
return PEM_DH_PARAMETERS;
// DSA Parameters
it = Search(sb, SBB_DSA_PARAMETERS_BEGIN);
if(it != sb.end())
return PEM_DSA_PARAMETERS;
// Certificate
it = Search(sb, SBB_CERTIFICATE_BEGIN);
if(it != sb.end())
return PEM_CERTIFICATE;
it = Search(sb, SBB_X509_CERTIFICATE_BEGIN);
if(it != sb.end())
return PEM_X509_CERTIFICATE;
it = Search(sb, SBB_REQ_CERTIFICATE_BEGIN);
if(it != sb.end())
return PEM_REQ_CERTIFICATE;
return PEM_UNSUPPORTED;
}
SecByteBlock::const_iterator Search(const SecByteBlock& source, const SecByteBlock& target)
{
return search(source.begin(), source.end(), target.begin(), target.end());
}
