#pragma once
#include "CertificateSummary.h"
#include "NotImplemented.h"
#include <wtf/Vector.h>
#include <wtf/persistence/PersistentCoders.h>
#include <wtf/persistence/PersistentDecoder.h>
#include <wtf/persistence/PersistentEncoder.h>
namespace WebCore {
class CertificateInfo {
public:
using Certificate = Vector<uint8_t>;
using CertificateChain = Vector<Certificate>;
CertificateInfo() = default;
WEBCORE_EXPORT CertificateInfo(int verificationError, CertificateChain&&);
WEBCORE_EXPORT CertificateInfo isolatedCopy() const;
int verificationError() const { return m_verificationError; }
WEBCORE_EXPORT String verificationErrorDescription() const;
const Vector<Certificate>& certificateChain() const { return m_certificateChain; }
bool containsNonRootSHA1SignedCertificate() const { notImplemented(); return false; }
Optional<CertificateSummary> summary() const;
bool isEmpty() const { return m_certificateChain.isEmpty(); }
static Certificate makeCertificate(const uint8_t*, size_t);
private:
int m_verificationError { 0 };
CertificateChain m_certificateChain;
};
inline bool operator==(const CertificateInfo& a, const CertificateInfo& b)
{
return a.verificationError() == b.verificationError() && a.certificateChain() == b.certificateChain();
}
}
namespace WTF {
namespace Persistence {
template<> struct Coder<WebCore::CertificateInfo> {
static void encode(Encoder& encoder, const WebCore::CertificateInfo& certificateInfo)
{
auto& certificateChain = certificateInfo.certificateChain();
encoder << certificateInfo.verificationError();
encoder << certificateChain.size();
for (auto& certificate : certificateChain)
encoder << certificate;
}
static Optional<WebCore::CertificateInfo> decode(Decoder& decoder)
{
Optional<int> verificationError;
decoder >> verificationError;
if (!verificationError)
return WTF::nullopt;
Optional<size_t> numOfCerts;
decoder >> numOfCerts;
if (!numOfCerts)
return WTF::nullopt;
WebCore::CertificateInfo::CertificateChain certificateChain;
for (size_t i = 0; i < numOfCerts.value(); i++) {
Optional<WebCore::CertificateInfo::Certificate> certificate;
decoder >> certificate;
if (!certificate)
return WTF::nullopt;
certificateChain.append(WTFMove(certificate.value()));
}
return WebCore::CertificateInfo(verificationError.value(), WTFMove(certificateChain));
}
};
} }