Per discussion, implement the Omaha Client Update Protocol (CUP) in src/crypto.

crypto/cup_nss.cc

+// Copyright (c) 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "crypto/cup.h"
+
+#include <base64.h>
+#include <keyhi.h>
+#include <pk11pub.h>
+#include <seccomon.h>
+
+#include "base/logging.h"
+#include "crypto/nss_util.h"
+#include "crypto/scoped_nss_types.h"
+
+using base::StringPiece;
+
+namespace crypto {
+
+typedef scoped_ptr_malloc<
+    CERTSubjectPublicKeyInfo,
+    NSSDestroyer<CERTSubjectPublicKeyInfo, SECKEY_DestroySubjectPublicKeyInfo> >
+    ScopedCERTSubjectPublicKeyInfo;
+
+size_t ClientUpdateProtocol::LoadPublicKey(const StringPiece& public_key) {
+  EnsureNSSInit();
+
+  // The binary blob |public_key| is expected to be a DER-encoded ASN.1-encoded

[wtc, 2013/05/30 21:38:56]

ASN.1-encoded => ASN.1

[Ryan Myers (chromium), 2013/05/30 21:55:11]

Done.

+  // Subject Public Key Info.
+  std::vector<unsigned char> pkey(public_key.begin(), public_key.end());
+  SECItem spki_item;
+  spki_item.type = siBuffer;
+  spki_item.data = &pkey[0];

[wtc, 2013/05/30 21:38:56]

You can set spki_item.data to (unsigned char*)public_key.data() directly.
(In proper C++ this requires a const_cast followed by a reinterpret_cast.)
It is not necessary to copy public_key to pkey.

SECKEY_DecodeDERSubjectPublicKeyInfo uses spki_item as const data, so the
const_cast is safe. (This is a limitation of the SECItem struct, whose |data|
field is a non-const pointer.)

[Ryan Myers (chromium), 2013/05/30 21:55:11]

Done.

+  spki_item.len = static_cast<unsigned int>(public_key.size());
+
+  ScopedCERTSubjectPublicKeyInfo spki(
+      SECKEY_DecodeDERSubjectPublicKeyInfo(&spki_item));
+  if (!spki.get())
+    return 0;
+
+  public_key_.reset(SECKEY_ExtractPublicKey(spki.get()));
+  if (!public_key_.get())
+    return 0;
+
+  return SECKEY_PublicKeyStrength(public_key_.get());
+}
+
+bool ClientUpdateProtocol::EncryptKeySource(
+    const std::vector<uint8>& key_source) {
+  // WARNING: This call bypasses the usual PKCS padding and does direct RSA

[wtc, 2013/05/30 21:38:56]

PKCS => PKCS #1

(There are other PKCS standards. One of them, PKCS #7, happens to also deal
with padding.)

[Ryan Myers (chromium), 2013/05/30 21:55:11]

Done.

+  // exponentiation.  This not secure without taking measures to ensure that

[wtc, 2013/05/30 21:38:56]

This not secure => This is not secure

[Ryan Myers (chromium), 2013/05/30 21:55:11]

Done.

+  // the contents of r are suitable.  This is done to remain compatible with
+  // the implementation on the Google Update servers; don't copy-paste this
+  // code arbitrarily and expect it to work and/or remain secure!
+  SECKEYPublicKey* pkv = public_key_.get();

[wtc, 2013/05/30 21:38:56]

The Style Guide recommends against variable names like |pkv| that are
uncommon abbreviations. You can name it |public_key| or |key|.

[Ryan Myers (chromium), 2013/05/30 21:55:11]

Done.

+  if (!pkv)
+    return false;
+
+  size_t keysize = SECKEY_PublicKeyStrength(pkv);
+  if (key_source.size() != keysize)
+    return false;
+
+  // Make a copy of the key source, since for some reason, the NSS function
+  // takes the data in a non-const pointer.

[wtc, 2013/05/30 21:38:56]

It *should* be safe to use a const_cast here as well because NSS does not
need to modify the data when encrypting it.

You can remove "for some reason" from the comment. I believe this is partly
because NSS wasn't very careful about using 'const' input arguments before,
and partly because the underlying PKCS #11 interface that NSS uses to talk
to crypto modules does not have a const pointer type.

[Ryan Myers (chromium), 2013/05/30 21:55:11]

Done.

+  std::vector<uint8> key_source_copy(key_source);
+
+  encrypted_key_source_.resize(keysize);
+  return SECSuccess == PK11_PubEncryptRaw(pkv,
+                                          &encrypted_key_source_[0],
+                                          &key_source_copy[0],
+                                          key_source_copy.size(),
+                                          NULL);
+}
+
+}  // namespace crypto
+