Line data    Source code

       1             : /*-
       2             :  * Copyright (c) 2005 Doug Rabson
       3             :  * All rights reserved.
       4             :  *
       5             :  * Redistribution and use in source and binary forms, with or without
       6             :  * modification, are permitted provided that the following conditions
       7             :  * are met:
       8             :  * 1. Redistributions of source code must retain the above copyright
       9             :  *    notice, this list of conditions and the following disclaimer.
      10             :  * 2. Redistributions in binary form must reproduce the above copyright
      11             :  *    notice, this list of conditions and the following disclaimer in the
      12             :  *    documentation and/or other materials provided with the distribution.
      13             :  *
      14             :  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
      15             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      16             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      17             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
      18             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      19             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      20             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      21             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      22             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      23             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      24             :  * SUCH DAMAGE.
      25             :  *
      26             :  *      $FreeBSD: src/lib/libgssapi/gss_utils.c,v 1.1 2005/12/29 14:40:20 dfr Exp $
      27             :  */
      28             : 
      29             : #include "mech_locl.h"
      30             : 
      31             : static OM_uint32
      32       88364 : _gss_copy_oid(OM_uint32 *minor_status,
      33             :               gss_const_OID from_oid,
      34             :               gss_OID to_oid)
      35             : {
      36       88364 :         size_t len = from_oid->length;
      37             : 
      38       88364 :         *minor_status = 0;
      39       88364 :         to_oid->elements = malloc(len);
      40       88364 :         if (!to_oid->elements) {
      41           0 :                 to_oid->length = 0;
      42           0 :                 *minor_status = ENOMEM;
      43           0 :                 return GSS_S_FAILURE;
      44             :         }
      45       88364 :         to_oid->length = (OM_uint32)len;
      46       88364 :         memcpy(to_oid->elements, from_oid->elements, len);
      47       88364 :         return (GSS_S_COMPLETE);
      48             : }
      49             : 
      50             : OM_uint32
      51           0 : _gss_free_oid(OM_uint32 *minor_status, gss_OID oid)
      52             : {
      53           0 :         *minor_status = 0;
      54           0 :         if (oid->elements) {
      55           0 :             free(oid->elements);
      56           0 :             oid->elements = NULL;
      57           0 :             oid->length = 0;
      58             :         }
      59           0 :         return (GSS_S_COMPLETE);
      60             : }
      61             : 
      62             : struct _gss_interned_oid {
      63             :     HEIM_SLIST_ATOMIC_ENTRY(_gss_interned_oid) gio_link;
      64             :     gss_OID_desc gio_oid;
      65             : };
      66             : 
      67             : static HEIM_SLIST_ATOMIC_HEAD(_gss_interned_oid_list, _gss_interned_oid) interned_oids =
      68             : HEIM_SLIST_HEAD_INITIALIZER(interned_oids);
      69             : 
      70             : extern gss_OID _gss_ot_internal[];
      71             : extern size_t _gss_ot_internal_count;
      72             : 
      73             : static OM_uint32
      74      350007 : intern_oid_static(OM_uint32 *minor_status,
      75             :                   gss_const_OID from_oid,
      76             :                   gss_OID *to_oid)
      77             : {
      78       11802 :     size_t i;
      79             : 
      80             :     /* statically allocated OIDs */
      81    20117751 :     for (i = 0; i < _gss_ot_internal_count; i++) {
      82    20005492 :         if (gss_oid_equal(_gss_ot_internal[i], from_oid)) {
      83      237748 :             *minor_status = 0;
      84      237748 :             *to_oid = _gss_ot_internal[i];
      85      237748 :             return GSS_S_COMPLETE;
      86             :         }
      87             :     }
      88             : 
      89      107652 :     return GSS_S_CONTINUE_NEEDED;
      90             : }
      91             : 
      92             : OM_uint32
      93      350007 : _gss_intern_oid(OM_uint32 *minor_status,
      94             :                 gss_const_OID from_oid,
      95             :                 gss_OID *to_oid)
      96             : {
      97       11802 :     OM_uint32 major_status;
      98       11802 :     struct _gss_interned_oid *iop;
      99             : 
     100      350007 :     major_status = intern_oid_static(minor_status, from_oid, to_oid);
     101      350007 :     if (major_status != GSS_S_CONTINUE_NEEDED)
     102      230553 :         return major_status;
     103             : 
     104      292574 :     HEIM_SLIST_ATOMIC_FOREACH(iop, &interned_oids, gio_link) {
     105      204210 :         if (gss_oid_equal(&iop->gio_oid, from_oid)) {
     106       23895 :             *minor_status = 0;
     107       23895 :             *to_oid = &iop->gio_oid;
     108       23895 :             return GSS_S_COMPLETE;
     109             :         }
     110             :     }
     111             : 
     112       88364 :     iop = malloc(sizeof(*iop));
     113       88364 :     if (iop == NULL) {
     114           0 :         *minor_status = ENOMEM;
     115           0 :         return GSS_S_FAILURE;
     116             :     }
     117             : 
     118       88364 :     major_status = _gss_copy_oid(minor_status, from_oid, &iop->gio_oid);
     119       88364 :     if (GSS_ERROR(major_status)) {
     120           0 :         free(iop);
     121           0 :         return major_status;
     122             :     }
     123             : 
     124       88364 :     HEIM_SLIST_ATOMIC_INSERT_HEAD(&interned_oids, iop, gio_link);
     125             : 
     126       88364 :     *minor_status = 0;
     127       88364 :     *to_oid = &iop->gio_oid;
     128             : 
     129       88364 :     return GSS_S_COMPLETE;
     130             : }
     131             : 
     132             : OM_uint32
     133       24016 : _gss_copy_buffer(OM_uint32 *minor_status,
     134             :     const gss_buffer_t from_buf, gss_buffer_t to_buf)
     135             : {
     136       24016 :         size_t len = from_buf->length;
     137             : 
     138       24016 :         *minor_status = 0;
     139       24016 :         to_buf->value = malloc(len);
     140       24016 :         if (!to_buf->value) {
     141           0 :                 *minor_status = ENOMEM;
     142           0 :                 to_buf->length = 0;
     143           0 :                 return GSS_S_FAILURE;
     144             :         }
     145       24016 :         to_buf->length = len;
     146       24016 :         memcpy(to_buf->value, from_buf->value, len);
     147       24016 :         return (GSS_S_COMPLETE);
     148             : }
     149             : 
     150             : OM_uint32
     151       73409 : _gss_secure_release_buffer(OM_uint32 *minor_status,
     152             :                            gss_buffer_t buffer)
     153             : {
     154       73409 :     if (buffer->value)
     155       73409 :         memset_s(buffer->value, buffer->length, 0, buffer->length);
     156             : 
     157       73409 :     return gss_release_buffer(minor_status, buffer);
     158             : }
     159             : 
     160             : OM_uint32
     161       72624 : _gss_secure_release_buffer_set(OM_uint32 *minor_status,
     162             :                                gss_buffer_set_t *buffer_set)
     163             : {
     164         978 :     size_t i;
     165         978 :     OM_uint32 minor;
     166             : 
     167       72624 :     *minor_status = 0;
     168             : 
     169       72624 :     if (*buffer_set == GSS_C_NO_BUFFER_SET)
     170           0 :         return GSS_S_COMPLETE;
     171             : 
     172      145248 :     for (i = 0; i < (*buffer_set)->count; i++)
     173       72624 :         _gss_secure_release_buffer(&minor, &((*buffer_set)->elements[i]));
     174             : 
     175       72624 :     (*buffer_set)->count = 0;
     176             : 
     177       72624 :     return gss_release_buffer_set(minor_status, buffer_set);
     178             : }
     179             : 
     180             : void
     181           0 : _gss_mg_encode_le_uint64(uint64_t n, uint8_t *p)
     182             : {
     183           0 :     p[0] = (n >> 0 ) & 0xFF;
     184           0 :     p[1] = (n >> 8 ) & 0xFF;
     185           0 :     p[2] = (n >> 16) & 0xFF;
     186           0 :     p[3] = (n >> 24) & 0xFF;
     187           0 :     p[4] = (n >> 32) & 0xFF;
     188           0 :     p[5] = (n >> 40) & 0xFF;
     189           0 :     p[6] = (n >> 48) & 0xFF;
     190           0 :     p[7] = (n >> 56) & 0xFF;
     191           0 : }
     192             : 
     193             : void
     194           0 : _gss_mg_decode_le_uint64(const void *ptr, uint64_t *n)
     195             : {
     196           0 :     const uint8_t *p = ptr;
     197           0 :     *n = ((uint64_t)p[0] << 0)
     198           0 :        | ((uint64_t)p[1] << 8)
     199           0 :        | ((uint64_t)p[2] << 16)
     200           0 :        | ((uint64_t)p[3] << 24)
     201           0 :        | ((uint64_t)p[4] << 32)
     202           0 :        | ((uint64_t)p[5] << 40)
     203           0 :        | ((uint64_t)p[6] << 48)
     204           0 :        | ((uint64_t)p[7] << 56);
     205           0 : }
     206             : 
     207             : void
     208           0 : _gss_mg_encode_be_uint64(uint64_t n, uint8_t *p)
     209             : {
     210           0 :     p[0] = (n >> 56) & 0xFF;
     211           0 :     p[1] = (n >> 48) & 0xFF;
     212           0 :     p[2] = (n >> 40) & 0xFF;
     213           0 :     p[3] = (n >> 32) & 0xFF;
     214           0 :     p[4] = (n >> 24) & 0xFF;
     215           0 :     p[5] = (n >> 16) & 0xFF;
     216           0 :     p[6] = (n >> 8 ) & 0xFF;
     217           0 :     p[7] = (n >> 0 ) & 0xFF;
     218           0 : }
     219             : 
     220             : void
     221           0 : _gss_mg_decode_be_uint64(const void *ptr, uint64_t *n)
     222             : {
     223           0 :     const uint8_t *p = ptr;
     224           0 :     *n = ((uint64_t)p[0] << 56)
     225           0 :        | ((uint64_t)p[1] << 48)
     226           0 :        | ((uint64_t)p[2] << 40)
     227           0 :        | ((uint64_t)p[3] << 32)
     228           0 :        | ((uint64_t)p[4] << 24)
     229           0 :        | ((uint64_t)p[5] << 16)
     230           0 :        | ((uint64_t)p[6] << 8)
     231           0 :        | ((uint64_t)p[7] << 0);
     232           0 : }
     233             : 
     234             : void
     235       47988 : _gss_mg_encode_le_uint32(uint32_t n, uint8_t *p)
     236             : {
     237       47988 :     p[0] = (n >> 0 ) & 0xFF;
     238       47988 :     p[1] = (n >> 8 ) & 0xFF;
     239       47988 :     p[2] = (n >> 16) & 0xFF;
     240       47988 :     p[3] = (n >> 24) & 0xFF;
     241       47988 : }
     242             : 
     243             : void
     244      104222 : _gss_mg_decode_le_uint32(const void *ptr, uint32_t *n)
     245             : {
     246      104222 :     const uint8_t *p = ptr;
     247      104222 :     *n = ((uint32_t)p[0] << 0)
     248      104222 :        | ((uint32_t)p[1] << 8)
     249      104222 :        | ((uint32_t)p[2] << 16)
     250      104222 :        | ((uint32_t)p[3] << 24);
     251      104222 : }
     252             : 
     253             : void
     254     4235833 : _gss_mg_encode_be_uint32(uint32_t n, uint8_t *p)
     255             : {
     256     4235833 :     p[0] = (n >> 24) & 0xFF;
     257     4235833 :     p[1] = (n >> 16) & 0xFF;
     258     4235833 :     p[2] = (n >> 8 ) & 0xFF;
     259     4235833 :     p[3] = (n >> 0 ) & 0xFF;
     260     4235833 : }
     261             : 
     262             : void
     263     2762027 : _gss_mg_decode_be_uint32(const void *ptr, uint32_t *n)
     264             : {
     265     2762027 :     const uint8_t *p = ptr;
     266     2762027 :     *n = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | (p[3] << 0);
     267     2762027 : }
     268             : 
     269             : void
     270           0 : _gss_mg_encode_le_uint16(uint16_t n, uint8_t *p)
     271             : {
     272           0 :     p[0] = (n >> 0 ) & 0xFF;
     273           0 :     p[1] = (n >> 8 ) & 0xFF;
     274           0 : }
     275             : 
     276             : void
     277           0 : _gss_mg_decode_le_uint16(const void *ptr, uint16_t *n)
     278             : {
     279           0 :     const uint8_t *p = ptr;
     280           0 :     *n = (p[0] << 0) | (p[1] << 8);
     281           0 : }
     282             : 
     283             : void
     284           0 : _gss_mg_encode_be_uint16(uint16_t n, uint8_t *p)
     285             : {
     286           0 :     p[0] = (n >> 8) & 0xFF;
     287           0 :     p[1] = (n >> 0) & 0xFF;
     288           0 : }
     289             : 
     290             : void
     291           0 : _gss_mg_decode_be_uint16(const void *ptr, uint16_t *n)
     292             : {
     293           0 :     const uint8_t *p = ptr;
     294           0 :     *n = (p[0] << 24) | (p[1] << 16);
     295           0 : }
     296             : 
     297             : OM_uint32
     298       46952 : _gss_mg_ret_oid(OM_uint32 *minor,
     299             :                 krb5_storage *sp,
     300             :                 gss_OID *oidp)
     301             : {
     302           0 :     krb5_data data;
     303           0 :     gss_OID_desc oid;
     304           0 :     OM_uint32 major;
     305             : 
     306       46952 :     *minor = 0;
     307       46952 :     *oidp = GSS_C_NO_OID;
     308             : 
     309       46952 :     *minor = krb5_ret_data(sp, &data);
     310       46952 :     if (*minor)
     311       23476 :         return GSS_S_FAILURE;
     312             : 
     313       23476 :     if (data.length) {
     314       23476 :         oid.length = data.length;
     315       23476 :         oid.elements = data.data;
     316             : 
     317       23476 :         major = _gss_intern_oid(minor, &oid, oidp);
     318             :     } else
     319           0 :         major = GSS_S_COMPLETE;
     320             : 
     321       23476 :     krb5_data_free(&data);
     322             : 
     323       23476 :     return major;
     324             : }
     325             : 
     326             : OM_uint32
     327         785 : _gss_mg_store_oid(OM_uint32 *minor,
     328             :                   krb5_storage *sp,
     329             :                   gss_const_OID oid)
     330             : {
     331           0 :     krb5_data data;
     332             : 
     333         785 :     if (oid) {
     334         785 :         data.length = oid->length;
     335         785 :         data.data = oid->elements;
     336             :     } else
     337           0 :         krb5_data_zero(&data);
     338             : 
     339         785 :     *minor = krb5_store_data(sp, data);
     340             : 
     341         785 :     return *minor ? GSS_S_FAILURE : GSS_S_COMPLETE;
     342             : }
     343             : 
     344             : OM_uint32
     345       23476 : _gss_mg_ret_buffer(OM_uint32 *minor,
     346             :                    krb5_storage *sp,
     347             :                    gss_buffer_t buffer)
     348             : {
     349           0 :     krb5_data data;
     350             : 
     351       23476 :     _mg_buffer_zero(buffer);
     352             : 
     353       23476 :     *minor = krb5_ret_data(sp, &data);
     354       23476 :     if (*minor == 0) {
     355       23476 :         if (data.length) {
     356       23476 :             buffer->length = data.length;
     357       23476 :             buffer->value = data.data;
     358             :         } else
     359           0 :             krb5_data_free(&data);
     360             :     }
     361             : 
     362       23476 :     return *minor ? GSS_S_FAILURE : GSS_S_COMPLETE;
     363             : }
     364             : 
     365             : OM_uint32
     366           0 : _gss_mg_store_buffer(OM_uint32 *minor,
     367             :                      krb5_storage *sp,
     368             :                      gss_const_buffer_t buffer)
     369             : {
     370           0 :     krb5_data data;
     371             : 
     372           0 :     if (buffer) {
     373           0 :         data.length = buffer->length;
     374           0 :         data.data = buffer->value;
     375             :     } else
     376           0 :         krb5_data_zero(&data);
     377             : 
     378           0 :     *minor =  krb5_store_data(sp, data);
     379             : 
     380           0 :     return *minor ? GSS_S_FAILURE : GSS_S_COMPLETE;
     381             : }