Use base::StringPiece for input parameters in Encryptor, rather than std::string

crypto/encryptor.h

 // Copyright (c) 2011 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.
 
 #ifndef CRYPTO_ENCRYPTOR_H_
 #define CRYPTO_ENCRYPTOR_H_
 #pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/scoped_ptr.h"
+#include "base/string_piece.h"
 #include "build/build_config.h"
 #include "crypto/crypto_api.h"
 
 #if defined(USE_NSS)
 #include "crypto/scoped_nss_types.h"
 #elif defined(OS_WIN)
 #include "crypto/scoped_capi_types.h"
 #endif
 
 namespace crypto {
 
 class SymmetricKey;
 
 class CRYPTO_API Encryptor {
  public:
   enum Mode {
     CBC,
     CTR,
   };
 
   // This class implements a 128-bits counter to be used in AES-CTR encryption.
   // Only 128-bits counter is supported in this class.
   class Counter {
    public:
-    Counter(const std::string& counter);
+    Counter(const base::StringPiece& counter);
     ~Counter();
 
     // Increment the counter value.
     bool Increment();
 
     // Write the content of the counter to |buf|. |buf| should have enough
     // space for |GetLengthInBytes()|.
     void Write(void* buf);
 
     // Return the length of this counter.
     size_t GetLengthInBytes() const;
 
    private:
     union {
       uint32 components32[4];
       uint64 components64[2];
     } counter_;
   };
 
   Encryptor();
   virtual ~Encryptor();
 
   // Initializes the encryptor using |key| and |iv|. Returns false if either the
   // key or the initialization vector cannot be used.
   //
   // When |mode| is CTR then |iv| should be empty.
-  bool Init(SymmetricKey* key, Mode mode, const std::string& iv);
+  bool Init(SymmetricKey* key, Mode mode, const base::StringPiece& iv);
 
   // Encrypts |plaintext| into |ciphertext|.
-  bool Encrypt(const std::string& plaintext, std::string* ciphertext);
+  bool Encrypt(const base::StringPiece& plaintext, std::string* ciphertext);
 
   // Decrypts |ciphertext| into |plaintext|.
-  bool Decrypt(const std::string& ciphertext, std::string* plaintext);
+  bool Decrypt(const base::StringPiece& ciphertext, std::string* plaintext);

[wtc, 2011/06/28 22:42:09]

It is strange to use StringPiece for input and std::string
for output in the Encrypt() and Decrypt() methods.

Can we not change these two methods?  Or can we also use
StringPiece for output?

This comment also applies to the private Crypt and CryptCTR
methods below.

[Ryan Sleevi, 2011/06/28 22:56:12]

No. base::StringPiece doesn't carry with it any ownership semantics - it's just
a pointer+size holder - the original object needs to stick around for the
duration of the StringPiece.

As a result, it's not possible to transfer ownership of a new pointer to the
caller. This would be equivalent to the signature
Encrypt(T* input_pointer, scoped_refptr<T>* output_pointer)

Unfortunately, we can't do something like StringPiece* because whatever the
StringPiece pointed to would be out of scope when the function returned.

The semantics could be changed if the caller was guaranteed to give a properly
sized StringPiece, we could write into it, but I think that's leaky on several
levels - most importantly, being that it requires the callers to know about
padding and block sizes, which I think would be a poor API.

 
   // Sets the counter value when in CTR mode. Currently only 128-bits
   // counter value is supported.
   //
   // Returns true only if update was successful.
-  bool SetCounter(const std::string& counter);
+  bool SetCounter(const base::StringPiece& counter);
 
   // TODO(albertb): Support streaming encryption.
 
  private:
   // Generates a mask using |counter_| to be used for encryption in CTR mode.
   // Resulting mask will be written to |mask| with |mask_len| bytes.
   //
   // Make sure there's enough space in mask when calling this method.
   // Reserve at least |plaintext_len| + 16 bytes for |mask|.
   //
@@ skipping 13 matching lines @@
                    size_t plaintext_len,
                    const void* mask,
                    void* ciphertext) const;
 
   SymmetricKey* key_;
   Mode mode_;
   scoped_ptr<Counter> counter_;
 
 #if defined(USE_OPENSSL)
   bool Crypt(bool encrypt,  // Pass true to encrypt, false to decrypt.
-             const std::string& input,
+             const base::StringPiece& input,
              std::string* output);
   std::string iv_;
 #elif defined(USE_NSS)
   bool Crypt(PK11Context* context,
-             const std::string& input,
+             const base::StringPiece& input,
              std::string* output);
   bool CryptCTR(PK11Context* context,
-                const std::string& input,
+                const base::StringPiece& input,
                 std::string* output);
   ScopedPK11Slot slot_;
   ScopedSECItem param_;
 #elif defined(OS_MACOSX)
   bool Crypt(int /*CCOperation*/ op,
-             const std::string& input,
+             const base::StringPiece& input,
              std::string* output);
 
   std::string iv_;
 #elif defined(OS_WIN)
   ScopedHCRYPTKEY capi_key_;
   DWORD block_size_;
 #endif
 };
 
 }  // namespace crypto
 
 #endif  // CRYPTO_ENCRYPTOR_H_