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