shibsp/attribute/KeyInfoAttributeDecoder.cpp

   1 /**
   2  * Licensed to the University Corporation for Advanced Internet
   3  * Development, Inc. (UCAID) under one or more contributor license
   4  * agreements. See the NOTICE file distributed with this work for
   5  * additional information regarding copyright ownership.
   6  *
   7  * UCAID licenses this file to you under the Apache License,
   8  * Version 2.0 (the "License"); you may not use this file except
   9  * in compliance with the License. You may obtain a copy of the
  10  * License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  17  * either express or implied. See the License for the specific
  18  * language governing permissions and limitations under the License.
  19  */
  20
  21 /**
  22  * KeyInfoAttributeDecoder.cpp
  23  *
  24  * Decodes KeyInfo information into a SimpleAttribute.
  25  */
  26
  27 #include "internal.h"
  28 #include "attribute/AttributeDecoder.h"
  29 #include "attribute/SimpleAttribute.h"
  30
  31 #include <saml/saml1/core/Assertions.h>
  32 #include <saml/saml2/core/Assertions.h>
  33 #include <xmltooling/XMLToolingConfig.h>
  34 #include <xmltooling/security/Credential.h>
  35 #include <xmltooling/security/KeyInfoResolver.h>
  36 #include <xmltooling/security/SecurityHelper.h>
  37 #include <xmltooling/signature/KeyInfo.h>
  38
  39 using namespace shibsp;
  40 using namespace opensaml;
  41 using namespace xmlsignature;
  42 using namespace xmltooling;
  43 using namespace std;
  44
  45 namespace shibsp {
  46     class SHIBSP_DLLLOCAL KeyInfoAttributeDecoder : virtual public AttributeDecoder
  47     {
  48     public:
  49         KeyInfoAttributeDecoder(const DOMElement* e);
  50         ~KeyInfoAttributeDecoder() {
  51             delete m_keyInfoResolver;
  52         }
  53
  54         Attribute* decode(
  55             const vector<string>& ids, const XMLObject* xmlObject, const char* assertingParty=nullptr, const char* relyingParty=nullptr
  56             ) const;
  57
  58     private:
  59         void extract(const KeyInfo* k, vector<string>& dest) const {
  60             auto_ptr<Credential> cred (getKeyInfoResolver()->resolve(k, Credential::RESOLVE_KEYS));
  61             if (cred.get()) {
  62                 dest.push_back(string());
  63                 dest.back() = SecurityHelper::getDEREncoding(*cred.get(), m_hash ? m_keyInfoHashAlg.c_str() : nullptr);
  64                 if (dest.back().empty())
  65                     dest.pop_back();
  66             }
  67         }
  68
  69         const KeyInfoResolver* getKeyInfoResolver() const {
  70             return m_keyInfoResolver ? m_keyInfoResolver : XMLToolingConfig::getConfig().getKeyInfoResolver();
  71         }
  72
  73         bool m_hash;
  74         string m_keyInfoHashAlg;
  75         KeyInfoResolver* m_keyInfoResolver;
  76     };
  77
  78     AttributeDecoder* SHIBSP_DLLLOCAL KeyInfoAttributeDecoderFactory(const DOMElement* const & e)
  79     {
  80         return new KeyInfoAttributeDecoder(e);
  81     }
  82
  83     static const XMLCh _KeyInfoResolver[] = UNICODE_LITERAL_15(K,e,y,I,n,f,o,R,e,s,o,l,v,e,r);
  84     static const XMLCh _hash[] =            UNICODE_LITERAL_4(h,a,s,h);
  85     static const XMLCh keyInfoHashAlg[] =   UNICODE_LITERAL_14(k,e,y,I,n,f,o,H,a,s,h,A,l,g);
  86     static const XMLCh _type[] =            UNICODE_LITERAL_4(t,y,p,e);
  87 };
  88
  89 KeyInfoAttributeDecoder::KeyInfoAttributeDecoder(const DOMElement* e)
  90     : AttributeDecoder(e),
  91         m_hash(XMLHelper::getAttrBool(e, false, _hash)),
  92         m_keyInfoHashAlg(XMLHelper::getAttrString(e, "SHA1", keyInfoHashAlg)),
  93         m_keyInfoResolver(nullptr) {
  94     e = XMLHelper::getFirstChildElement(e,_KeyInfoResolver);
  95     if (e) {
  96         string t(XMLHelper::getAttrString(e, nullptr, _type));
  97         if (t.empty())
  98             throw UnknownExtensionException("<KeyInfoResolver> element found with no type attribute");
  99         m_keyInfoResolver = XMLToolingConfig::getConfig().KeyInfoResolverManager.newPlugin(t.c_str(), e);
 100     }
 101 }
 102
 103 Attribute* KeyInfoAttributeDecoder::decode(
 104     const vector<string>& ids, const XMLObject* xmlObject, const char* assertingParty, const char* relyingParty
 105     ) const
 106 {
 107     Category& log = Category::getInstance(SHIBSP_LOGCAT".AttributeDecoder.KeyInfo");
 108
 109     if (!xmlObject || !XMLString::equals(saml1::Attribute::LOCAL_NAME, xmlObject->getElementQName().getLocalPart())) {
 110         log.warn("XMLObject type not recognized by KeyInfoAttributeDecoder, no values returned");
 111         return nullptr;
 112     }
 113
 114     auto_ptr<SimpleAttribute> attr(new SimpleAttribute(ids));
 115     vector<string>& dest = attr->getValues();
 116     vector<XMLObject*>::const_iterator v,stop;
 117
 118     const saml2::Attribute* saml2attr = dynamic_cast<const saml2::Attribute*>(xmlObject);
 119     if (saml2attr) {
 120         const vector<XMLObject*>& values = saml2attr->getAttributeValues();
 121         v = values.begin();
 122         stop = values.end();
 123         if (log.isDebugEnabled()) {
 124             auto_ptr_char n(saml2attr->getName());
 125             log.debug(
 126                 "decoding KeyInfo information (%s) from SAML 2 Attribute (%s) with %lu value(s)",
 127                 ids.front().c_str(), n.get() ? n.get() : "unnamed", values.size()
 128                 );
 129         }
 130     }
 131     else {
 132         const saml1::Attribute* saml1attr = dynamic_cast<const saml1::Attribute*>(xmlObject);
 133         if (saml1attr) {
 134             const vector<XMLObject*>& values = saml1attr->getAttributeValues();
 135             v = values.begin();
 136             stop = values.end();
 137             if (log.isDebugEnabled()) {
 138                 auto_ptr_char n(saml1attr->getAttributeName());
 139                 log.debug(
 140                     "decoding KeyInfo information (%s) from SAML 1 Attribute (%s) with %lu value(s)",
 141                     ids.front().c_str(), n.get() ? n.get() : "unnamed", values.size()
 142                     );
 143             }
 144         }
 145         else {
 146             log.warn("XMLObject type not recognized by KeyInfoAttributeDecoder, no values returned");
 147             return nullptr;
 148         }
 149     }
 150
 151     for (; v!=stop; ++v) {
 152         const KeyInfo* k = dynamic_cast<const KeyInfo*>(*v);
 153         if (k)
 154             extract(k, dest);
 155         else if ((*v)->hasChildren()) {
 156             const list<XMLObject*>& children = (*v)->getOrderedChildren();
 157             for (list<XMLObject*>::const_iterator vv = children.begin(); vv!=children.end(); ++vv) {
 158                 if (k=dynamic_cast<const KeyInfo*>(*vv))
 159                     extract(k, dest);
 160                 else
 161                     log.warn("skipping AttributeValue without a recognizable KeyInfo");
 162             }
 163         }
 164     }
 165
 166     return dest.empty() ? nullptr : _decode(attr.release());
 167 }