xmltooling/security/impl/CredentialCriteria.cpp

   1 /*
   2  *  Copyright 2001-2010 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  * CredentialCriteria.cpp
  19  *
  20  * Class for specifying criteria by which a CredentialResolver should resolve credentials.
  21  */
  22
  23 #include "internal.h"
  24 #include "logging.h"
  25 #include "XMLToolingConfig.h"
  26 #include "security/X509Credential.h"
  27 #include "security/CredentialCriteria.h"
  28 #include "security/KeyInfoResolver.h"
  29 #include "security/SecurityHelper.h"
  30 #include "signature/Signature.h"
  31
  32 #include <openssl/dsa.h>
  33 #include <openssl/rsa.h>
  34 #include <xsec/dsig/DSIGKeyInfoList.hpp>
  35 #include <xsec/enc/OpenSSL/OpenSSLCryptoKeyDSA.hpp>
  36 #include <xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.hpp>
  37
  38 using xmlsignature::KeyInfo;
  39 using xmlsignature::Signature;
  40 using namespace xmltooling::logging;
  41 using namespace xmltooling;
  42 using namespace std;
  43
  44 CredentialCriteria::CredentialCriteria()
  45     : m_keyUsage(Credential::UNSPECIFIED_CREDENTIAL), m_keySize(0), m_maxKeySize(0), m_key(nullptr),
  46         m_keyInfo(nullptr), m_nativeKeyInfo(nullptr), m_credential(nullptr)
  47 {
  48 }
  49
  50 CredentialCriteria::~CredentialCriteria()
  51 {
  52     delete m_credential;
  53 }
  54
  55 unsigned int CredentialCriteria::getUsage() const
  56 {
  57     return m_keyUsage;
  58 }
  59
  60 void CredentialCriteria::setUsage(unsigned int usage)
  61 {
  62     m_keyUsage = usage;
  63 }
  64
  65 const char* CredentialCriteria::getPeerName() const
  66 {
  67     return m_peerName.empty() ? nullptr : m_peerName.c_str();
  68 }
  69
  70 void CredentialCriteria::setPeerName(const char* peerName)
  71 {
  72     m_peerName.erase();
  73     if (peerName)
  74         m_peerName = peerName;
  75 }
  76
  77 const char* CredentialCriteria::getKeyAlgorithm() const
  78 {
  79     return m_keyAlgorithm.empty() ? nullptr : m_keyAlgorithm.c_str();
  80 }
  81
  82 void CredentialCriteria::setKeyAlgorithm(const char* keyAlgorithm)
  83 {
  84     m_keyAlgorithm.erase();
  85     if (keyAlgorithm)
  86         m_keyAlgorithm = keyAlgorithm;
  87 }
  88
  89 unsigned int CredentialCriteria::getKeySize() const
  90 {
  91     return m_keySize;
  92 }
  93
  94 void CredentialCriteria::setKeySize(unsigned int keySize)
  95 {
  96     m_keySize = keySize;
  97 }
  98
  99 unsigned int CredentialCriteria::getMaxKeySize() const
 100 {
 101     return m_maxKeySize;
 102 }
 103
 104 void CredentialCriteria::setMaxKeySize(unsigned int keySize)
 105 {
 106     m_maxKeySize = keySize;
 107 }
 108
 109 void CredentialCriteria::setXMLAlgorithm(const XMLCh* algorithm)
 110 {
 111     if (algorithm) {
 112         pair<const char*,unsigned int> mapped = XMLToolingConfig::getConfig().mapXMLAlgorithmToKeyAlgorithm(algorithm);
 113         setKeyAlgorithm(mapped.first);
 114         setKeySize(mapped.second);
 115     }
 116     else {
 117         setKeyAlgorithm(nullptr);
 118         setKeySize(0);
 119     }
 120 }
 121
 122 const set<string>& CredentialCriteria::getKeyNames() const
 123 {
 124     return m_keyNames;
 125 }
 126
 127 set<string>& CredentialCriteria::getKeyNames()
 128 {
 129     return m_keyNames;
 130 }
 131
 132 XSECCryptoKey* CredentialCriteria::getPublicKey() const
 133 {
 134     return m_key;
 135 }
 136
 137 void CredentialCriteria::setPublicKey(XSECCryptoKey* key)
 138 {
 139     m_key = key;
 140 }
 141
 142 const KeyInfo* CredentialCriteria::getKeyInfo() const
 143 {
 144     return m_keyInfo;
 145 }
 146
 147 void CredentialCriteria::setKeyInfo(const KeyInfo* keyInfo, int extraction)
 148 {
 149     delete m_credential;
 150     m_credential = nullptr;
 151     m_keyInfo = keyInfo;
 152     if (!keyInfo || !extraction)
 153         return;
 154
 155     int types = (extraction & KEYINFO_EXTRACTION_KEY) ? Credential::RESOLVE_KEYS : 0;
 156     types |= (extraction & KEYINFO_EXTRACTION_KEYNAMES) ? X509Credential::RESOLVE_CERTS : 0;
 157     m_credential = XMLToolingConfig::getConfig().getKeyInfoResolver()->resolve(keyInfo,types);
 158
 159     // Ensure any key names have been sucked out for later if desired.
 160     if (extraction & KEYINFO_EXTRACTION_KEYNAMES) {
 161         X509Credential* xcred = dynamic_cast<X509Credential*>(m_credential);
 162         if (xcred)
 163             xcred->extract();
 164     }
 165 }
 166
 167 DSIGKeyInfoList* CredentialCriteria::getNativeKeyInfo() const
 168 {
 169     return m_nativeKeyInfo;
 170 }
 171
 172 void CredentialCriteria::setNativeKeyInfo(DSIGKeyInfoList* keyInfo, int extraction)
 173 {
 174     delete m_credential;
 175     m_credential = nullptr;
 176     m_nativeKeyInfo = keyInfo;
 177     if (!keyInfo || !extraction)
 178         return;
 179
 180     int types = (extraction & KEYINFO_EXTRACTION_KEY) ? Credential::RESOLVE_KEYS : 0;
 181     types |= (extraction & KEYINFO_EXTRACTION_KEYNAMES) ? X509Credential::RESOLVE_CERTS : 0;
 182     m_credential = XMLToolingConfig::getConfig().getKeyInfoResolver()->resolve(keyInfo,types);
 183
 184     // Ensure any key names have been sucked out for later if desired.
 185     if (extraction & KEYINFO_EXTRACTION_KEYNAMES) {
 186         X509Credential* xcred = dynamic_cast<X509Credential*>(m_credential);
 187         if (xcred)
 188             xcred->extract();
 189     }
 190 }
 191
 192 void CredentialCriteria::setSignature(const Signature& sig, int extraction)
 193 {
 194     setXMLAlgorithm(sig.getSignatureAlgorithm());
 195     KeyInfo* k = sig.getKeyInfo();
 196     if (k)
 197         return setKeyInfo(k, extraction);
 198     DSIGSignature* dsig = sig.getXMLSignature();
 199     if (dsig)
 200         setNativeKeyInfo(dsig->getKeyInfoList(), extraction);
 201 }
 202
 203 void CredentialCriteria::reset()
 204 {
 205     setUsage(Credential::UNSPECIFIED_CREDENTIAL);
 206     setKeySize(0);
 207     setMaxKeySize(0);
 208     setKeyAlgorithm(nullptr);
 209     getKeyNames().clear();
 210     setKeyInfo(nullptr);
 211     setNativeKeyInfo(nullptr);
 212 }
 213
 214 bool CredentialCriteria::matches(const Credential& credential) const
 215 {
 216     Category& log = Category::getInstance(XMLTOOLING_LOGCAT".CredentialCriteria");
 217
 218     // Usage check, if specified and we have one, compare masks.
 219     if (getUsage() != Credential::UNSPECIFIED_CREDENTIAL) {
 220         if (credential.getUsage() != Credential::UNSPECIFIED_CREDENTIAL)
 221             if ((getUsage() & credential.getUsage()) == 0) {
 222                 if (log.isDebugEnabled())
 223                     log.debug("usage didn't match (%u != %u)", getUsage(), credential.getUsage());
 224                 return false;
 225             }
 226     }
 227
 228     // Algorithm check, if specified and we have one.
 229     const char* alg = getKeyAlgorithm();
 230     if (alg && *alg) {
 231         const char* alg2 = credential.getAlgorithm();
 232         if (alg2 && *alg2) {
 233             if (strcmp(alg,alg2)) {
 234                 if (log.isDebugEnabled())
 235                     log.debug("key algorithm didn't match ('%s' != '%s')", getKeyAlgorithm(), credential.getAlgorithm());
 236                 return false;
 237             }
 238         }
 239     }
 240
 241     // KeySize check, if specified and we have one.
 242     unsigned int ksize = credential.getKeySize();
 243     if (ksize > 0) {
 244         if (m_keySize > 0 && m_maxKeySize == 0) {
 245             if (ksize != m_keySize) {
 246                 log.debug("key size (%u) didn't match (%u)", ksize, m_keySize);
 247                 return false;
 248             }
 249         }
 250         else if (m_keySize > 0 && ksize < m_keySize) {
 251             log.debug("key size (%u) smaller than minimum (%u)", ksize, m_keySize);
 252             return false;
 253         }
 254         else if (m_maxKeySize > 0 && ksize > m_maxKeySize) {
 255             log.debug("key size (%u) larger than maximum (%u)", ksize, m_maxKeySize);
 256             return false;
 257         }
 258     }
 259
 260     // See if we can test key names.
 261     set<string> critnames = getKeyNames();
 262     if (m_credential)
 263         critnames.insert(m_credential->getKeyNames().begin(), m_credential->getKeyNames().end());
 264     const set<string>& crednames = credential.getKeyNames();
 265     if (!critnames.empty() && !crednames.empty()) {
 266         bool found = false;
 267         for (set<string>::const_iterator n = critnames.begin(); n!=critnames.end(); ++n) {
 268             if (crednames.count(*n)>0) {
 269                 found = true;
 270                 break;
 271             }
 272         }
 273         if (!found) {
 274             log.debug("credential name(s) didn't overlap");
 275             return false;
 276         }
 277     }
 278
 279     // See if we have to match a specific key.
 280     const XSECCryptoKey* key1 = getPublicKey();
 281     if (!key1 && m_credential)
 282         key1 = m_credential->getPublicKey();
 283     if (!key1)
 284         return true;    // no key to compare against, so we're done
 285
 286     const XSECCryptoKey* key2 = credential.getPublicKey();
 287     if (!key2)
 288         return true;   // no key here, so we can't test it
 289
 290     if (SecurityHelper::matches(*key1, *key2))
 291         return true;
 292
 293     log.debug("keys didn't match");
 294     return false;
 295 }