crypto/secure_hash_default.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "crypto/secure_hash.h"
   6
   7 #include "base/logging.h"
   8 #include "base/pickle.h"
   9 #include "crypto/third_party/nss/chromium-blapi.h"
  10 #include "crypto/third_party/nss/chromium-sha256.h"
  11
  12 namespace crypto {
  13
  14 namespace {
  15
  16 const char kSHA256Descriptor[] = "NSS";
  17
  18 class SecureHashSHA256NSS : public SecureHash {
  19  public:
  20   static const int kSecureHashVersion = 1;
  21
  22   SecureHashSHA256NSS() {
  23     SHA256_Begin(&ctx_);
  24   }
  25
  26   virtual ~SecureHashSHA256NSS() {
  27   }
  28
  29   // SecureHash implementation:
  30   virtual void Update(const void* input, size_t len) OVERRIDE {
  31     SHA256_Update(&ctx_, static_cast<const unsigned char*>(input), len);
  32   }
  33
  34   virtual void Finish(void* output, size_t len) OVERRIDE {
  35     SHA256_End(&ctx_, static_cast<unsigned char*>(output), NULL,
  36                static_cast<unsigned int>(len));
  37   }
  38
  39   virtual bool Serialize(Pickle* pickle) OVERRIDE;
  40   virtual bool Deserialize(PickleIterator* data_iterator) OVERRIDE;
  41
  42  private:
  43   SHA256Context ctx_;
  44 };
  45
  46 bool SecureHashSHA256NSS::Serialize(Pickle* pickle) {
  47   if (!pickle)
  48     return false;
  49
  50   if (!pickle->WriteInt(kSecureHashVersion) ||
  51       !pickle->WriteString(kSHA256Descriptor) ||
  52       !pickle->WriteBytes(&ctx_, sizeof(ctx_))) {
  53     return false;
  54   }
  55
  56   return true;
  57 }
  58
  59 bool SecureHashSHA256NSS::Deserialize(PickleIterator* data_iterator) {
  60   int version;
  61   if (!data_iterator->ReadInt(&version))
  62     return false;
  63
  64   if (version > kSecureHashVersion)
  65     return false;  // We don't know how to deal with this.
  66
  67   std::string type;
  68   if (!data_iterator->ReadString(&type))
  69     return false;
  70
  71   if (type != kSHA256Descriptor)
  72     return false;  // It's the wrong kind.
  73
  74   const char* data = NULL;
  75   if (!data_iterator->ReadBytes(&data, sizeof(ctx_)))
  76     return false;
  77
  78   memcpy(&ctx_, data, sizeof(ctx_));
  79
  80   return true;
  81 }
  82
  83 }  // namespace
  84
  85 SecureHash* SecureHash::Create(Algorithm algorithm) {
  86   switch (algorithm) {
  87     case SHA256:
  88       return new SecureHashSHA256NSS();
  89     default:
  90       NOTIMPLEMENTED();
  91       return NULL;
  92   }
  93 }
  94
  95 }  // namespace crypto