plugins/GSSAPIAttributeExtractor.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  * GSSAPIAttributeExtractor.cpp
  23  *
  24  * AttributeExtractor for a base64-encoded GSS-API context or name.
  25  */
  26
  27 #include "internal.h"
  28
  29 #ifdef HAVE_GSSAPI_NAMINGEXTS
  30
  31 #include <shibsp/exceptions.h>
  32 #include <shibsp/Application.h>
  33 #include <shibsp/SPConfig.h>
  34 #include <shibsp/attribute/BinaryAttribute.h>
  35 #include <shibsp/attribute/ScopedAttribute.h>
  36 #include <shibsp/attribute/SimpleAttribute.h>
  37 #include <shibsp/attribute/resolver/AttributeExtractor.h>
  38 #include <shibsp/remoting/ddf.h>
  39 #include <shibsp/util/SPConstants.h>
  40 #include <saml/saml1/core/Assertions.h>
  41 #include <saml/saml2/metadata/Metadata.h>
  42 #include <xmltooling/unicode.h>
  43 #include <xmltooling/XMLToolingConfig.h>
  44 #include <xmltooling/util/NDC.h>
  45 #include <xmltooling/util/ReloadableXMLFile.h>
  46 #include <xmltooling/util/Threads.h>
  47 #include <xmltooling/util/XMLHelper.h>
  48 #include <xercesc/util/Base64.hpp>
  49 #include <xercesc/util/XMLUniDefs.hpp>
  50 #include <boost/algorithm/string.hpp>
  51
  52 #ifdef SHIBSP_HAVE_GSSGNU
  53 # include <gss.h>
  54 #elif defined SHIBSP_HAVE_GSSMIT
  55 # include <gssapi/gssapi_ext.h>
  56 #else
  57 # include <gssapi.h>
  58 #endif
  59
  60
  61 using namespace shibsp;
  62 using namespace opensaml::saml2md;
  63 using namespace opensaml;
  64 using namespace xmltooling;
  65 using namespace xercesc;
  66 using namespace boost;
  67 using namespace std;
  68
  69 namespace shibsp {
  70
  71 #if defined (_MSC_VER)
  72     #pragma warning( push )
  73     #pragma warning( disable : 4250 )
  74 #endif
  75
  76     class GSSAPIExtractorImpl
  77     {
  78     public:
  79         GSSAPIExtractorImpl(const DOMElement* e, Category& log);
  80         ~GSSAPIExtractorImpl() {
  81             if (m_document)
  82                 m_document->release();
  83         }
  84
  85         void setDocument(DOMDocument* doc) {
  86             m_document = doc;
  87         }
  88
  89         void extractAttributes(gss_name_t initiatorName, vector<Attribute*>& attributes) const;
  90         void extractAttributes(gss_name_t initiatorName, gss_buffer_t namingAttribute, vector<Attribute*>& attributes) const;
  91
  92         void getAttributeIds(vector<string>& attributes) const {
  93             attributes.insert(attributes.end(), m_attributeIds.begin(), m_attributeIds.end());
  94         }
  95
  96     private:
  97         struct Rule {
  98             Rule() : authenticated(true), binary(false), scopeDelimiter(0) {}
  99             vector<string> ids;
 100             bool authenticated,binary;
 101             char scopeDelimiter;
 102         };
 103
 104         Category& m_log;
 105         DOMDocument* m_document;
 106         map<string,Rule> m_attrMap;
 107         vector<string> m_attributeIds;
 108     };
 109
 110     class GSSAPIExtractor : public AttributeExtractor, public ReloadableXMLFile
 111     {
 112     public:
 113         GSSAPIExtractor(const DOMElement* e)
 114                 : ReloadableXMLFile(e, Category::getInstance(SHIBSP_LOGCAT".AttributeExtractor.GSSAPI")) {
 115             background_load();
 116         }
 117         ~GSSAPIExtractor() {
 118             shutdown();
 119         }
 120
 121         void extractAttributes(
 122             const Application& application,
 123             const RoleDescriptor* issuer,
 124             const XMLObject& xmlObject,
 125             vector<Attribute*>& attributes
 126             ) const;
 127
 128         void getAttributeIds(std::vector<std::string>& attributes) const {
 129             if (m_impl)
 130                 m_impl->getAttributeIds(attributes);
 131         }
 132
 133     protected:
 134         pair<bool,DOMElement*> background_load();
 135
 136     private:
 137         scoped_ptr<GSSAPIExtractorImpl> m_impl;
 138     };
 139
 140 #if defined (_MSC_VER)
 141     #pragma warning( pop )
 142 #endif
 143
 144     AttributeExtractor* GSSAPIExtractorFactory(const DOMElement* const & e)
 145     {
 146         return new GSSAPIExtractor(e);
 147     }
 148
 149     static const XMLCh _aliases[] =             UNICODE_LITERAL_7(a,l,i,a,s,e,s);
 150     static const XMLCh Attributes[] =           UNICODE_LITERAL_10(A,t,t,r,i,b,u,t,e,s);
 151     static const XMLCh _authenticated[] =       UNICODE_LITERAL_13(a,u,t,h,e,n,t,i,c,a,t,e,d);
 152     static const XMLCh _binary[] =              UNICODE_LITERAL_6(b,i,n,a,r,y);
 153     static const XMLCh GSSAPIAttribute[] =      UNICODE_LITERAL_15(G,S,S,A,P,I,A,t,t,r,i,b,u,t,e);
 154     static const XMLCh _id[] =                  UNICODE_LITERAL_2(i,d);
 155     static const XMLCh _name[] =                UNICODE_LITERAL_4(n,a,m,e);
 156     static const XMLCh _scopeDelimiter[] =      UNICODE_LITERAL_14(s,c,o,p,e,D,e,l,i,m,i,t,e,r);
 157 };
 158
 159 GSSAPIExtractorImpl::GSSAPIExtractorImpl(const DOMElement* e, Category& log)
 160     : m_log(log), m_document(nullptr)
 161 {
 162 #ifdef _DEBUG
 163     xmltooling::NDC ndc("GSSAPIExtractorImpl");
 164 #endif
 165
 166     if (!XMLHelper::isNodeNamed(e, shibspconstants::SHIB2ATTRIBUTEMAP_NS, Attributes))
 167         throw ConfigurationException("GSSAPI AttributeExtractor requires am:Attributes at root of configuration.");
 168
 169     DOMElement* child = XMLHelper::getFirstChildElement(e, shibspconstants::SHIB2ATTRIBUTEMAP_NS, GSSAPIAttribute);
 170     while (child) {
 171         // Check for missing name or id.
 172         const XMLCh* name = child->getAttributeNS(nullptr, _name);
 173         if (!name || !*name) {
 174             m_log.warn("skipping GSSAPIAttribute with no name");
 175             child = XMLHelper::getNextSiblingElement(child, shibspconstants::SHIB2ATTRIBUTEMAP_NS, GSSAPIAttribute);
 176             continue;
 177         }
 178
 179         auto_ptr_char id(child->getAttributeNS(nullptr, _id));
 180         if (!id.get() || !*id.get()) {
 181             m_log.warn("skipping GSSAPIAttribute with no id");
 182             child = XMLHelper::getNextSiblingElement(child, shibspconstants::SHIB2ATTRIBUTEMAP_NS, GSSAPIAttribute);
 183             continue;
 184         }
 185         else if (!strcmp(id.get(), "REMOTE_USER")) {
 186             m_log.warn("skipping GSSAPIAttribute, id of REMOTE_USER is a reserved name");
 187             child = XMLHelper::getNextSiblingElement(child, shibspconstants::SHIB2ATTRIBUTEMAP_NS, GSSAPIAttribute);
 188             continue;
 189         }
 190
 191         // Fetch/create the map entry and see if it's a duplicate rule.
 192         auto_ptr_char attrname(name);
 193         Rule& decl = m_attrMap[attrname.get()];
 194         if (!decl.ids.empty()) {
 195             m_log.warn("skipping duplicate GSS-API Attribute mapping (same name)");
 196             child = XMLHelper::getNextSiblingElement(child, shibspconstants::SHIB2ATTRIBUTEMAP_NS, GSSAPIAttribute);
 197             continue;
 198         }
 199
 200         m_log.info("creating mapping for GSS-API Attribute %s", attrname.get());
 201
 202         decl.ids.push_back(id.get());
 203         m_attributeIds.push_back(id.get());
 204
 205         name = child->getAttributeNS(nullptr, _aliases);
 206         if (name && *name) {
 207             auto_ptr_char aliases(name);
 208             string dup(aliases.get());
 209             set<string> new_aliases;
 210             split(new_aliases, dup, is_space(), algorithm::token_compress_on);
 211             set<string>::iterator ru = new_aliases.find("REMOTE_USER");
 212             if (ru != new_aliases.end()) {
 213                 m_log.warn("skipping alias, REMOTE_USER is a reserved name");
 214                 new_aliases.erase(ru);
 215             }
 216             m_attributeIds.insert(m_attributeIds.end(), new_aliases.begin(), new_aliases.end());
 217         }
 218
 219         decl.authenticated = XMLHelper::getAttrBool(child, true, _authenticated);
 220         decl.binary = XMLHelper::getAttrBool(child, false, _binary);
 221         string delim = XMLHelper::getAttrString(child, "", _scopeDelimiter);
 222         if (!delim.empty())
 223             decl.scopeDelimiter = delim[0];
 224
 225         child = XMLHelper::getNextSiblingElement(child, shibspconstants::SHIB2ATTRIBUTEMAP_NS, GSSAPIAttribute);
 226     }
 227 }
 228
 229 void GSSAPIExtractorImpl::extractAttributes(gss_name_t initiatorName, vector<Attribute*>& attributes) const
 230 {
 231     OM_uint32 minor;
 232     gss_buffer_set_t attrnames = GSS_C_NO_BUFFER_SET;
 233     OM_uint32 major = gss_inquire_name(&minor, initiatorName, nullptr, nullptr, &attrnames);
 234     if (major == GSS_S_COMPLETE) {
 235         for (size_t i = 0; i < attrnames->count; ++i) {
 236             extractAttributes(initiatorName, &attrnames->elements[i], attributes);
 237         }
 238         gss_release_buffer_set(&minor, &attrnames);
 239     }
 240     else {
 241         m_log.warn("unable to extract attributes, GSS name attribute inquiry failed (%u:%u)", major, minor);
 242     }
 243 }
 244
 245 void GSSAPIExtractorImpl::extractAttributes(
 246     gss_name_t initiatorName, gss_buffer_t namingAttribute, vector<Attribute*>& attributes
 247     ) const
 248 {
 249     // First we have to determine if this GSS attribute is something we recognize.
 250     string attrname(reinterpret_cast<char*>(namingAttribute->value), namingAttribute->length);
 251     map<string,Rule>::const_iterator rule = m_attrMap.find(attrname);
 252     if (rule == m_attrMap.end()) {
 253         m_log.info("skipping unmapped GSS-API attribute: %s", attrname.c_str());
 254         return;
 255     }
 256
 257     vector<string> values;
 258
 259     OM_uint32 major,minor;
 260     int authenticated=-1,more=-1;
 261     do {
 262         gss_buffer_desc buf = GSS_C_EMPTY_BUFFER;
 263         major = gss_get_name_attribute(
 264             &minor, initiatorName, namingAttribute, &authenticated, nullptr, &buf, nullptr, &more
 265             );
 266         if (major == GSS_S_COMPLETE) {
 267             if (rule->second.authenticated && !authenticated) {
 268                 m_log.warn("skipping unauthenticated GSS-API attribute: %s", attrname.c_str());
 269                 gss_release_buffer(&minor, &buf);
 270                 return;
 271             }
 272             if (buf.length) {
 273                 values.push_back(string(reinterpret_cast<char*>(buf.value), buf.length));
 274             }
 275             gss_release_buffer(&minor, &buf);
 276         }
 277         else {
 278             m_log.warn("error obtaining values for GSS-API attribute (%s): %u:%u", attrname.c_str(), major, minor);
 279         }
 280     } while (major == GSS_S_COMPLETE && more);
 281
 282     if (values.empty())
 283         return;
 284
 285     if (rule->second.scopeDelimiter && !rule->second.binary) {
 286         auto_ptr<ScopedAttribute> scoped(new ScopedAttribute(rule->second.ids, rule->second.scopeDelimiter));
 287         vector< pair<string,string> >& dest = scoped->getValues();
 288         for (vector<string>::const_iterator v = values.begin(); v != values.end(); ++v) {
 289             const char* value = v->c_str();
 290             const char* scope = strchr(value, rule->second.scopeDelimiter);
 291             if (scope) {
 292                 if (*(scope+1))
 293                     dest.push_back(pair<string,string>(v->substr(0, scope-value), scope + 1));
 294                 else
 295                     m_log.warn("ignoring unscoped value");
 296             }
 297             else {
 298                 m_log.warn("ignoring unscoped value");
 299             }
 300         }
 301         if (!scoped->getValues().empty()) {
 302             attributes.push_back(scoped.get());
 303             scoped.release();
 304         }
 305     }
 306     else if (rule->second.binary) {
 307         auto_ptr<BinaryAttribute> binary(new BinaryAttribute(rule->second.ids));
 308         binary->getValues() = values;
 309         attributes.push_back(binary.get());
 310         binary.release();
 311     }
 312     else {
 313         auto_ptr<SimpleAttribute> simple(new SimpleAttribute(rule->second.ids));
 314         simple->getValues() = values;
 315         attributes.push_back(simple.get());
 316         simple.release();
 317     }
 318 }
 319
 320 void GSSAPIExtractor::extractAttributes(
 321     const Application& application, const RoleDescriptor* issuer, const XMLObject& xmlObject, vector<Attribute*>& attributes
 322     ) const
 323 {
 324     if (!m_impl)
 325         return;
 326
 327     static const XMLCh _GSSAPIContext[] = UNICODE_LITERAL_13(G,S,S,A,P,I,C,o,n,t,e,x,t);
 328     static const XMLCh _GSSAPIName[] = UNICODE_LITERAL_10(G,S,S,A,P,I,N,a,m,e);
 329
 330     if (!XMLString::equals(xmlObject.getElementQName().getLocalPart(), _GSSAPIContext)
 331            && !XMLString::equals(xmlObject.getElementQName().getLocalPart(), _GSSAPIName)
 332         ) {
 333         m_log.debug("unable to extract attributes, unknown XML object type: %s", xmlObject.getElementQName().toString().c_str());
 334         return;
 335     }
 336
 337     const XMLCh* encodedWide = xmlObject.getTextContent();
 338     if (!encodedWide || !*encodedWide) {
 339         m_log.warn("unable to extract attributes, GSSAPI element had no text content");
 340         return;
 341     }
 342
 343     xsecsize_t x;
 344     OM_uint32 major,minor;
 345     auto_ptr_char encoded(encodedWide);
 346
 347     gss_name_t srcname;
 348     gss_ctx_id_t gss = GSS_C_NO_CONTEXT;
 349
 350     XMLByte* decoded=Base64::decode(reinterpret_cast<const XMLByte*>(encoded.get()), &x);
 351     if (decoded) {
 352         gss_buffer_desc importbuf;
 353         importbuf.length = x;
 354         importbuf.value = decoded;
 355         if (XMLString::equals(xmlObject.getElementQName().getLocalPart(), _GSSAPIName)) {
 356 #ifdef HAVE_GSSAPI_COMPOSITE_NAME
 357             major = gss_import_name(&minor, &importbuf, GSS_C_NT_EXPORT_NAME_COMPOSITE, &srcname);
 358 #else
 359             major = gss_import_name(&minor, &importbuf, GSS_C_NT_EXPORT_NAME, &srcname);
 360 #endif
 361             if (major == GSS_S_COMPLETE) {
 362                 m_impl->extractAttributes(srcname, attributes);
 363                 gss_release_name(&minor, &srcname);
 364             }
 365             else {
 366                 m_log.warn("unable to extract attributes, GSS name import failed (%u:%u)", major, minor);
 367             }
 368             // We fall through here down to the GSS context check, which will exit us.
 369         }
 370         else {
 371             major = gss_import_sec_context(&minor, &importbuf, &gss);
 372             if (major != GSS_S_COMPLETE) {
 373                 m_log.warn("unable to extract attributes, GSS context import failed (%u:%u)", major, minor);
 374                 gss = GSS_C_NO_CONTEXT;
 375             }
 376         }
 377 #ifdef SHIBSP_XERCESC_HAS_XMLBYTE_RELEASE
 378         XMLString::release(&decoded);
 379 #else
 380         XMLString::release((char**)&decoded);
 381 #endif
 382     }
 383     else {
 384         m_log.warn("unable to extract attributes, base64 decode of GSSAPI context or name failed");
 385     }
 386
 387     if (gss == GSS_C_NO_CONTEXT) {
 388         return;
 389     }
 390
 391     // Extract the initiator name from the context.
 392     major = gss_inquire_context(&minor, gss, &srcname, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
 393     if (major == GSS_S_COMPLETE) {
 394         m_impl->extractAttributes(srcname, attributes);
 395         gss_release_name(&minor, &srcname);
 396     }
 397     else {
 398         m_log.warn("unable to extract attributes, GSS initiator name extraction failed (%u:%u)", major, minor);
 399     }
 400
 401     gss_delete_sec_context(&minor, &gss, GSS_C_NO_BUFFER);
 402 }
 403
 404 pair<bool,DOMElement*> GSSAPIExtractor::background_load()
 405 {
 406     // Load from source using base class.
 407     pair<bool,DOMElement*> raw = ReloadableXMLFile::load();
 408
 409     // If we own it, wrap it.
 410     XercesJanitor<DOMDocument> docjanitor(raw.first ? raw.second->getOwnerDocument() : nullptr);
 411
 412     scoped_ptr<GSSAPIExtractorImpl> impl(new GSSAPIExtractorImpl(raw.second, m_log));
 413
 414     // If we held the document, transfer it to the impl. If we didn't, it's a no-op.
 415     impl->setDocument(docjanitor.release());
 416
 417     // Perform the swap inside a lock.
 418     if (m_lock)
 419         m_lock->wrlock();
 420     SharedLock locker(m_lock, false);
 421     m_impl.swap(impl);
 422
 423     return make_pair(false,(DOMElement*)nullptr);
 424 }
 425
 426 #endif