crypto/scoped_capi_types.h

   1 // Copyright (c) 2011 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 #ifndef CRYPTO_SCOPED_CAPI_TYPES_H_
   6 #define CRYPTO_SCOPED_CAPI_TYPES_H_
   7 #pragma once
   8
   9 #include <windows.h>
  10 #include <wincrypt.h>
  11
  12 #include <algorithm>
  13
  14 #include "base/logging.h"
  15
  16 namespace crypto {
  17
  18 // Simple destructor for the Free family of CryptoAPI functions, such as
  19 // CryptDestroyHash, which take only a single argument to release.
  20 template <typename CAPIHandle, BOOL (WINAPI *Destroyer)(CAPIHandle)>
  21 struct CAPIDestroyer {
  22   void operator()(CAPIHandle handle) const {
  23     if (handle) {
  24       BOOL ok = Destroyer(handle);
  25       DCHECK(ok);
  26     }
  27   }
  28 };
  29
  30 // Destructor for the Close/Release family of CryptoAPI functions, which take
  31 // a second DWORD parameter indicating flags to use when closing or releasing.
  32 // This includes functions like CertCloseStore or CryptReleaseContext.
  33 template <typename CAPIHandle, BOOL (WINAPI *Destroyer)(CAPIHandle, DWORD),
  34           DWORD flags>
  35 struct CAPIDestroyerWithFlags {
  36   void operator()(CAPIHandle handle) const {
  37     if (handle) {
  38       BOOL ok = Destroyer(handle, flags);
  39       DCHECK(ok);
  40     }
  41   }
  42 };
  43
  44 // scoped_ptr-like class for the CryptoAPI cryptography and certificate
  45 // handles. Because these handles are defined as integer types, and not
  46 // pointers, the existing scoped classes, such as scoped_ptr_malloc, are
  47 // insufficient. The semantics are the same as scoped_ptr.
  48 template <class CAPIHandle, typename FreeProc>
  49 class ScopedCAPIHandle {
  50  public:
  51   explicit ScopedCAPIHandle(CAPIHandle handle = NULL) : handle_(handle) {}
  52
  53   ~ScopedCAPIHandle() {
  54     reset();
  55   }
  56
  57   void reset(CAPIHandle handle = NULL) {
  58     if (handle_ != handle) {
  59       FreeProc free_proc;
  60       free_proc(handle_);
  61       handle_ = handle;
  62     }
  63   }
  64
  65   operator CAPIHandle() const { return handle_; }
  66   CAPIHandle get() const { return handle_; }
  67
  68   CAPIHandle* receive() {
  69     CHECK(handle_ == NULL);
  70     return &handle_;
  71   }
  72
  73   bool operator==(CAPIHandle handle) const {
  74     return handle_ == handle;
  75   }
  76
  77   bool operator!=(CAPIHandle handle) const {
  78     return handle_ != handle;
  79   }
  80
  81   void swap(ScopedCAPIHandle& b) {
  82     CAPIHandle tmp = b.handle_;
  83     b.handle_ = handle_;
  84     handle_ = tmp;
  85   }
  86
  87   CAPIHandle release() {
  88     CAPIHandle tmp = handle_;
  89     handle_ = NULL;
  90     return tmp;
  91   }
  92
  93  private:
  94   CAPIHandle handle_;
  95
  96   DISALLOW_COPY_AND_ASSIGN(ScopedCAPIHandle);
  97 };
  98
  99 template<class CH, typename FP> inline
 100 bool operator==(CH h, const ScopedCAPIHandle<CH, FP>& b) {
 101   return h == b.get();
 102 }
 103
 104 template<class CH, typename FP> inline
 105 bool operator!=(CH h, const ScopedCAPIHandle<CH, FP>& b) {
 106   return h != b.get();
 107 }
 108
 109 typedef ScopedCAPIHandle<
 110     HCRYPTPROV,
 111     CAPIDestroyerWithFlags<HCRYPTPROV,
 112                            CryptReleaseContext, 0> > ScopedHCRYPTPROV;
 113
 114 typedef ScopedCAPIHandle<
 115     HCRYPTKEY, CAPIDestroyer<HCRYPTKEY, CryptDestroyKey> > ScopedHCRYPTKEY;
 116
 117 typedef ScopedCAPIHandle<
 118     HCRYPTHASH, CAPIDestroyer<HCRYPTHASH, CryptDestroyHash> > ScopedHCRYPTHASH;
 119
 120 }  // namespace crypto
 121
 122 #endif  // CRYPTO_SCOPED_CAPI_TYPES_H_