source4/heimdal/lib/gssapi/mech/gss_cred.c

   1 /*
   2  * Copyright (c) 2017 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of KTH nor the names of its contributors may be
  18  *    used to endorse or promote products derived from this software without
  19  *    specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include "mech_locl.h"
  35 #include <krb5.h>
  36
  37 static OM_uint32
  38 store_mech_oid_and_oid_set(OM_uint32 *minor_status,
  39                            krb5_storage *sp,
  40                            gss_const_OID mech,
  41                            gss_const_OID_set oids)
  42 {
  43     OM_uint32 ret;
  44     size_t i, len;
  45
  46     ret = _gss_mg_store_oid(minor_status, sp, mech);
  47     if (ret)
  48         return ret;
  49
  50     for (i = 0, len = 0; i < oids->count; i++)
  51         len += 4 + oids->elements[i].length;
  52
  53     *minor_status = krb5_store_uint32(sp, len);
  54     if (*minor_status)
  55         return GSS_S_FAILURE;
  56
  57     for (i = 0; i < oids->count; i++) {
  58         ret = _gss_mg_store_oid(minor_status, sp, &oids->elements[i]);
  59         if (ret)
  60             return ret;
  61     }
  62
  63     return GSS_S_COMPLETE;
  64 }
  65
  66
  67 /*
  68  * format: any number of:
  69  *     mech-len: int32
  70  *     mech-data: char * (not alligned)
  71  *     cred-len: int32
  72  *     cred-data char * (not alligned)
  73  *
  74  * where neg_mechs is encoded for GSS_SPNEGO_MECHANISM
  75 */
  76
  77 GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
  78 gss_export_cred(OM_uint32 * minor_status,
  79                 gss_cred_id_t cred_handle,
  80                 gss_buffer_t token)
  81 {
  82     struct _gss_cred *cred = (struct _gss_cred *)cred_handle;
  83     struct _gss_mechanism_cred *mc;
  84     gss_buffer_desc buffer;
  85     krb5_error_code ret;
  86     krb5_ssize_t bytes;
  87     krb5_storage *sp;
  88     OM_uint32 major;
  89     krb5_data data;
  90
  91     _mg_buffer_zero(token);
  92
  93     if (cred == NULL) {
  94         *minor_status = 0;
  95         return GSS_S_NO_CRED;
  96     }
  97
  98     HEIM_TAILQ_FOREACH(mc, &cred->gc_mc, gmc_link) {
  99         if (mc->gmc_mech->gm_export_cred == NULL) {
 100             *minor_status = 0;
 101             gss_mg_set_error_string(&mc->gmc_mech->gm_mech_oid,
 102                                     GSS_S_NO_CRED, *minor_status,
 103                                     "Credential doesn't support exporting");
 104             return GSS_S_NO_CRED;
 105         }
 106     }
 107
 108     sp = krb5_storage_emem();
 109     if (sp == NULL) {
 110         *minor_status = ENOMEM;
 111         return GSS_S_FAILURE;
 112     }
 113
 114     HEIM_TAILQ_FOREACH(mc, &cred->gc_mc, gmc_link) {
 115         major = mc->gmc_mech->gm_export_cred(minor_status,
 116                                              mc->gmc_cred, &buffer);
 117         if (major) {
 118             krb5_storage_free(sp);
 119             return major;
 120         }
 121
 122         if (buffer.length) {
 123             bytes = krb5_storage_write(sp, buffer.value, buffer.length);
 124             if (bytes < 0 || (size_t)bytes != buffer.length) {
 125                 _gss_secure_release_buffer(minor_status, &buffer);
 126                 krb5_storage_free(sp);
 127                 *minor_status = EINVAL;
 128                 return GSS_S_FAILURE;
 129             }
 130         }
 131         _gss_secure_release_buffer(minor_status, &buffer);
 132     }
 133
 134     if (cred->gc_neg_mechs != GSS_C_NO_OID_SET) {
 135         major = store_mech_oid_and_oid_set(minor_status, sp,
 136                                            GSS_SPNEGO_MECHANISM,
 137                                            cred->gc_neg_mechs);
 138         if (major != GSS_S_COMPLETE) {
 139             krb5_storage_free(sp);
 140             return major;
 141         }
 142     }
 143
 144     ret = krb5_storage_to_data(sp, &data);
 145     krb5_storage_free(sp);
 146     if (ret) {
 147         *minor_status = ret;
 148         return GSS_S_FAILURE;
 149     }
 150
 151     if (data.length == 0) {
 152         *minor_status = 0;
 153         gss_mg_set_error_string(GSS_C_NO_OID,
 154                                 GSS_S_NO_CRED, *minor_status,
 155                                 "Credential was not exportable");
 156         return GSS_S_NO_CRED;
 157     }
 158
 159     token->value = data.data;
 160     token->length = data.length;
 161
 162     return GSS_S_COMPLETE;
 163 }
 164
 165 static OM_uint32
 166 import_oid_set(OM_uint32 *minor_status,
 167                gss_const_buffer_t token,
 168                gss_OID_set *oids)
 169 {
 170     OM_uint32 major, junk;
 171     krb5_storage *sp = NULL;
 172
 173     *oids = GSS_C_NO_OID_SET;
 174
 175     if (token->length == 0)
 176         return GSS_S_COMPLETE;
 177
 178     major = gss_create_empty_oid_set(minor_status, oids);
 179     if (major != GSS_S_COMPLETE)
 180         goto out;
 181
 182     sp = krb5_storage_from_readonly_mem(token->value, token->length);
 183     if (sp == NULL) {
 184         *minor_status = ENOMEM;
 185         major = GSS_S_FAILURE;
 186         goto out;
 187     }
 188
 189     while (1) {
 190         gss_OID oid;
 191
 192         major = _gss_mg_ret_oid(minor_status, sp, &oid);
 193         if (*minor_status == (OM_uint32)HEIM_ERR_EOF)
 194             break;
 195         else if (major)
 196             goto out;
 197
 198         major = gss_add_oid_set_member(minor_status, oid, oids);
 199         if (major != GSS_S_COMPLETE)
 200             goto out;
 201     }
 202
 203     major = GSS_S_COMPLETE;
 204     *minor_status = 0;
 205
 206 out:
 207     if (major != GSS_S_COMPLETE)
 208         gss_release_oid_set(&junk, oids);
 209     krb5_storage_free(sp);
 210
 211     return major;
 212 }
 213
 214 GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL
 215 gss_import_cred(OM_uint32 * minor_status,
 216                 gss_buffer_t token,
 217                 gss_cred_id_t * cred_handle)
 218 {
 219     gssapi_mech_interface m;
 220     struct _gss_cred *cred;
 221     krb5_storage *sp = NULL;
 222     OM_uint32 major, junk;
 223
 224     *cred_handle = GSS_C_NO_CREDENTIAL;
 225
 226     if (token->length == 0) {
 227         *minor_status = ENOMEM;
 228         return GSS_S_FAILURE;
 229     }
 230
 231     sp = krb5_storage_from_readonly_mem(token->value, token->length);
 232     if (sp == NULL) {
 233         *minor_status = ENOMEM;
 234         return GSS_S_FAILURE;
 235     }
 236
 237     cred = _gss_mg_alloc_cred();
 238     if (cred == NULL) {
 239         krb5_storage_free(sp);
 240         *minor_status = ENOMEM;
 241         return GSS_S_FAILURE;
 242     }
 243
 244     *cred_handle = (gss_cred_id_t)cred;
 245
 246     while(1) {
 247         struct _gss_mechanism_cred *mc;
 248         gss_buffer_desc buffer;
 249         gss_cred_id_t mcred;
 250         gss_OID oid;
 251
 252         major = _gss_mg_ret_oid(minor_status, sp, &oid);
 253         if (*minor_status == (OM_uint32)HEIM_ERR_EOF)
 254             break;
 255         else if (major != GSS_S_COMPLETE)
 256             goto out;
 257
 258         m = __gss_get_mechanism(oid);
 259         if (!m) {
 260             *minor_status = 0;
 261             major = GSS_S_BAD_MECH;
 262             goto out;
 263         }
 264
 265         if (m->gm_import_cred == NULL &&
 266             !gss_oid_equal(&m->gm_mech_oid, GSS_SPNEGO_MECHANISM)) {
 267             *minor_status = 0;
 268             major = GSS_S_BAD_MECH;
 269             goto out;
 270         }
 271
 272         major = _gss_mg_ret_buffer(minor_status, sp, &buffer);
 273         if (major != GSS_S_COMPLETE)
 274             goto out;
 275
 276         if (buffer.value == NULL) {
 277             major = GSS_S_DEFECTIVE_TOKEN;
 278             goto out;
 279         }
 280
 281         if (gss_oid_equal(&m->gm_mech_oid, GSS_SPNEGO_MECHANISM)) {
 282             major = import_oid_set(minor_status, &buffer, &cred->gc_neg_mechs);
 283             gss_release_buffer(&junk, &buffer);
 284             if (major != GSS_S_COMPLETE)
 285                 goto out;
 286             else
 287                 continue;
 288         }
 289
 290         major = m->gm_import_cred(minor_status,
 291                                   &buffer, &mcred);
 292         gss_release_buffer(&junk, &buffer);
 293         if (major != GSS_S_COMPLETE)
 294             goto out;
 295
 296         mc = calloc(1, sizeof(struct _gss_mechanism_cred));
 297         if (mc == NULL) {
 298             *minor_status = EINVAL;
 299             major = GSS_S_FAILURE;
 300             goto out;
 301         }
 302
 303         mc->gmc_mech = m;
 304         mc->gmc_mech_oid = &m->gm_mech_oid;
 305         mc->gmc_cred = mcred;
 306
 307         HEIM_TAILQ_INSERT_TAIL(&cred->gc_mc, mc, gmc_link);
 308     }
 309     krb5_storage_free(sp);
 310     sp = NULL;
 311
 312     if (HEIM_TAILQ_EMPTY(&cred->gc_mc)) {
 313         major = GSS_S_NO_CRED;
 314         goto out;
 315     }
 316
 317     return GSS_S_COMPLETE;
 318
 319  out:
 320     if (sp)
 321         krb5_storage_free(sp);
 322
 323     gss_release_cred(&junk, cred_handle);
 324
 325     return major;
 326
 327 }
 328