9478437fde
1. Constructors, SetData(), and AppendData() now accept uint8_t*,
int8_t*, and char*. Previously, they accepted void*, meaning that
any kind of pointer was accepted. I think requiring an explicit
cast in cases where the input array isn't already of a byte-sized
type is a better compromise between convenience and safety.
2. data() can now return a uint8_t* instead of a char*, which seems
more appropriate for a byte array, and is harder to mix up with
zero-terminated C strings. data<int8_t>() is also available so
that callers that want that type instead won't have to cast, as
is data<char>() (which remains the default until all existing
callers have been fixed).
3. Constructors, SetData(), and AppendData() now accept arrays
natively, not just decayed to pointers. The advantage of this is
that callers don't have to pass the size separately.
4. There are new constructors that allow setting size and capacity
without initializing the array. Previously, this had to be done
separately after construction.
5. Instead of TransferTo(), Buffer now supports swap(), and move
construction and assignment, and has a Pass() method that works
just like std::move(). (The Pass method is modeled after
scoped_ptr::Pass().)
R=jmarusic@webrtc.org, tommi@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/42989004
Cr-Commit-Position: refs/heads/master@{#9033}
98 lines
3.3 KiB
C++
98 lines
3.3 KiB
C++
/*
|
|
* Copyright 2012 The WebRTC Project Authors. All rights reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef WEBRTC_BASE_FAKESSLIDENTITY_H_
|
|
#define WEBRTC_BASE_FAKESSLIDENTITY_H_
|
|
|
|
#include <algorithm>
|
|
#include <vector>
|
|
|
|
#include "webrtc/base/common.h"
|
|
#include "webrtc/base/messagedigest.h"
|
|
#include "webrtc/base/sslidentity.h"
|
|
|
|
namespace rtc {
|
|
|
|
class FakeSSLCertificate : public rtc::SSLCertificate {
|
|
public:
|
|
// SHA-1 is the default digest algorithm because it is available in all build
|
|
// configurations used for unit testing.
|
|
explicit FakeSSLCertificate(const std::string& data)
|
|
: data_(data), digest_algorithm_(DIGEST_SHA_1) {}
|
|
explicit FakeSSLCertificate(const std::vector<std::string>& certs)
|
|
: data_(certs.front()), digest_algorithm_(DIGEST_SHA_1) {
|
|
std::vector<std::string>::const_iterator it;
|
|
// Skip certs[0].
|
|
for (it = certs.begin() + 1; it != certs.end(); ++it) {
|
|
certs_.push_back(FakeSSLCertificate(*it));
|
|
}
|
|
}
|
|
virtual FakeSSLCertificate* GetReference() const {
|
|
return new FakeSSLCertificate(*this);
|
|
}
|
|
virtual std::string ToPEMString() const {
|
|
return data_;
|
|
}
|
|
virtual void ToDER(Buffer* der_buffer) const {
|
|
std::string der_string;
|
|
VERIFY(SSLIdentity::PemToDer(kPemTypeCertificate, data_, &der_string));
|
|
der_buffer->SetData(der_string.c_str(), der_string.size());
|
|
}
|
|
void set_digest_algorithm(const std::string& algorithm) {
|
|
digest_algorithm_ = algorithm;
|
|
}
|
|
virtual bool GetSignatureDigestAlgorithm(std::string* algorithm) const {
|
|
*algorithm = digest_algorithm_;
|
|
return true;
|
|
}
|
|
virtual bool ComputeDigest(const std::string& algorithm,
|
|
unsigned char* digest,
|
|
size_t size,
|
|
size_t* length) const {
|
|
*length = rtc::ComputeDigest(algorithm, data_.c_str(), data_.size(),
|
|
digest, size);
|
|
return (*length != 0);
|
|
}
|
|
virtual bool GetChain(SSLCertChain** chain) const {
|
|
if (certs_.empty())
|
|
return false;
|
|
std::vector<SSLCertificate*> new_certs(certs_.size());
|
|
std::transform(certs_.begin(), certs_.end(), new_certs.begin(), DupCert);
|
|
*chain = new SSLCertChain(new_certs);
|
|
std::for_each(new_certs.begin(), new_certs.end(), DeleteCert);
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
static FakeSSLCertificate* DupCert(FakeSSLCertificate cert) {
|
|
return cert.GetReference();
|
|
}
|
|
static void DeleteCert(SSLCertificate* cert) { delete cert; }
|
|
std::string data_;
|
|
std::vector<FakeSSLCertificate> certs_;
|
|
std::string digest_algorithm_;
|
|
};
|
|
|
|
class FakeSSLIdentity : public rtc::SSLIdentity {
|
|
public:
|
|
explicit FakeSSLIdentity(const std::string& data) : cert_(data) {}
|
|
explicit FakeSSLIdentity(const FakeSSLCertificate& cert) : cert_(cert) {}
|
|
virtual FakeSSLIdentity* GetReference() const {
|
|
return new FakeSSLIdentity(*this);
|
|
}
|
|
virtual const FakeSSLCertificate& certificate() const { return cert_; }
|
|
private:
|
|
FakeSSLCertificate cert_;
|
|
};
|
|
|
|
} // namespace rtc
|
|
|
|
#endif // WEBRTC_BASE_FAKESSLIDENTITY_H_
|