xmltooling/security/CredentialCriteria.h

   1 /*
   2  *  Copyright 2001-2009 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @file xmltooling/security/CredentialCriteria.h
  19  *
  20  * Class for specifying criteria by which a CredentialResolver should resolve credentials.
  21  */
  22
  23 #if !defined(__xmltooling_credcrit_h__) && !defined(XMLTOOLING_NO_XMLSEC)
  24 #define __xmltooling_credcrit_h__
  25
  26 #include <xmltooling/base.h>
  27
  28 #include <set>
  29
  30 class DSIGKeyInfoList;
  31 class XSECCryptoKey;
  32
  33 namespace xmlsignature {
  34     class XMLTOOL_API KeyInfo;
  35     class XMLTOOL_API Signature;
  36 };
  37
  38 namespace xmltooling {
  39
  40     class XMLTOOL_API Credential;
  41
  42 #if defined (_MSC_VER)
  43     #pragma warning( push )
  44     #pragma warning( disable : 4251 )
  45 #endif
  46
  47     /**
  48      * Class for specifying criteria by which a CredentialResolver should resolve credentials.
  49      */
  50     class XMLTOOL_API CredentialCriteria
  51     {
  52         MAKE_NONCOPYABLE(CredentialCriteria);
  53     public:
  54         /** Default constructor. */
  55         CredentialCriteria();
  56
  57         virtual ~CredentialCriteria();
  58
  59         /**
  60          * Determines whether the supplied Credential matches this CredentialCriteria.
  61          *
  62          * @param credential    the Credential to evaluate
  63          * @return true iff the Credential is consistent with this criteria
  64          */
  65         virtual bool matches(const Credential& credential) const;
  66
  67         /**
  68          * Get key usage criteria.
  69          *
  70          * @return the usage mask
  71          */
  72         unsigned int getUsage() const;
  73
  74         /**
  75          * Set key usage criteria.
  76          *
  77          * @param usage the usage mask to set
  78          */
  79         void setUsage(unsigned int usage);
  80
  81         /**
  82          * Get the peer name criteria.
  83          *
  84          * @return the peer name
  85          */
  86         const char* getPeerName() const;
  87
  88         /**
  89          * Set the peer name criteria.
  90          *
  91          * @param peerName peer name to set
  92          */
  93         void setPeerName(const char* peerName);
  94
  95         /**
  96          * Get the key algorithm criteria.
  97          *
  98          * @return the key algorithm
  99          */
 100         const char* getKeyAlgorithm() const;
 101
 102         /**
 103          * Set the key algorithm criteria.
 104          *
 105          * @param keyAlgorithm The key algorithm to set
 106          */
 107         void setKeyAlgorithm(const char* keyAlgorithm);
 108
 109         /**
 110          * Get the key size criteria.
 111          *
 112          * @return  the key size, or 0
 113          */
 114         unsigned int getKeySize() const;
 115
 116         /**
 117          * Set the key size criteria.
 118          *
 119          * @param keySize Key size to set
 120          */
 121         void setKeySize(unsigned int keySize);
 122
 123         /**
 124          * Set the key algorithm and size criteria based on an XML algorithm specifier.
 125          *
 126          * @param algorithm XML algorithm specifier
 127          */
 128         void setXMLAlgorithm(const XMLCh* algorithm);
 129
 130         /**
 131          * Gets key name criteria.
 132          *
 133          * @return an immutable set of key names
 134          */
 135         const std::set<std::string>& getKeyNames() const;
 136
 137         /**
 138          * Gets key name criteria.
 139          *
 140          * @return a mutable set of key names
 141          */
 142         std::set<std::string>& getKeyNames();
 143
 144         /**
 145          * Returns the public key criteria.
 146          *
 147          * @return  a public key
 148          */
 149         virtual XSECCryptoKey* getPublicKey() const;
 150
 151         /**
 152          * Sets the public key criteria.
 153          *
 154          * <p>The lifetime of the key <strong>MUST</strong> extend
 155          * for the lifetime of this object.
 156          *
 157          * @param key a public key
 158          */
 159         void setPublicKey(XSECCryptoKey* key);
 160
 161         /**
 162          * Bitmask constants controlling the kinds of criteria set automatically
 163          * based on a KeyInfo object.
 164          */
 165         enum keyinfo_extraction_t {
 166             KEYINFO_EXTRACTION_KEY = 1,
 167             KEYINFO_EXTRACTION_KEYNAMES = 2
 168         };
 169
 170         /**
 171          * Gets the KeyInfo criteria.
 172          *
 173          * @return the KeyInfo criteria
 174          */
 175         const xmlsignature::KeyInfo* getKeyInfo() const;
 176
 177         /**
 178          * Sets the KeyInfo criteria.
 179          *
 180          * @param keyInfo       the KeyInfo criteria
 181          * @param extraction    bitmask of criteria to auto-extract from KeyInfo
 182          */
 183         virtual void setKeyInfo(const xmlsignature::KeyInfo* keyInfo, int extraction=0);
 184
 185         /**
 186          * Gets the native KeyInfo criteria.
 187          *
 188          * @return the native KeyInfo criteria
 189          */
 190         DSIGKeyInfoList* getNativeKeyInfo() const;
 191
 192         /**
 193          * Sets the KeyInfo criteria.
 194          *
 195          * @param keyInfo       the KeyInfo criteria
 196          * @param extraction    bitmask of criteria to auto-extract from KeyInfo
 197          */
 198         virtual void setNativeKeyInfo(DSIGKeyInfoList* keyInfo, int extraction=0);
 199
 200         /**
 201          * Sets the KeyInfo criteria from an XML Signature.
 202          *
 203          * @param sig           the Signature containing KeyInfo criteria
 204          * @param extraction    bitmask of criteria to auto-extract from KeyInfo
 205          */
 206         void setSignature(const xmlsignature::Signature& sig, int extraction=0);
 207
 208     private:
 209         unsigned int m_keyUsage;
 210         unsigned int m_keySize;
 211         std::string m_peerName,m_keyAlgorithm;
 212         std::set<std::string> m_keyNames;
 213         XSECCryptoKey* m_key;
 214         const xmlsignature::KeyInfo* m_keyInfo;
 215         DSIGKeyInfoList* m_nativeKeyInfo;
 216         Credential* m_credential;
 217     };
 218
 219 #if defined (_MSC_VER)
 220     #pragma warning( pop )
 221 #endif
 222 };
 223
 224 #endif /* __xmltooling_credcrit_h__ */