LCOV - code coverage report
Current view: top level - lib/gs2 - client.c (source / functions) Hit Total Coverage
Test: GNU SASL Lines: 116 138 84.1 %
Date: 2010-09-27 Functions: 6 6 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 50 72 69.4 %

           Branch data     Line data    Source code
       1                 :            : /* client.c --- SASL mechanism GS2, client side.
       2                 :            :  * Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2010  Simon Josefsson
       3                 :            :  *
       4                 :            :  * This file is part of GNU SASL Library.
       5                 :            :  *
       6                 :            :  * GNU SASL Library is free software; you can redistribute it and/or
       7                 :            :  * modify it under the terms of the GNU Lesser General Public License
       8                 :            :  * as published by the Free Software Foundation; either version 2.1 of
       9                 :            :  * the License, or (at your option) any later version.
      10                 :            :  *
      11                 :            :  * GNU SASL Library is distributed in the hope that it will be useful,
      12                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      14                 :            :  * Lesser General Public License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU Lesser General Public
      17                 :            :  * License along with GNU SASL Library; if not, write to the Free
      18                 :            :  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      19                 :            :  * Boston, MA 02110-1301, USA.
      20                 :            :  *
      21                 :            :  */
      22                 :            : 
      23                 :            : #ifdef HAVE_CONFIG_H
      24                 :            : # include "config.h"
      25                 :            : #endif
      26                 :            : 
      27                 :            : /* Get specification. */
      28                 :            : #include "gs2.h"
      29                 :            : 
      30                 :            : /* Get malloc, free. */
      31                 :            : #include <stdlib.h>
      32                 :            : 
      33                 :            : /* Get memcpy, strlen. */
      34                 :            : #include <string.h>
      35                 :            : 
      36                 :            : #include "gss-extra.h"
      37                 :            : #include "gs2helper.h"
      38                 :            : 
      39                 :            : struct _gsasl_gs2_client_state
      40                 :            : {
      41                 :            :   /* steps: 0 = initial, 1 = first token, 2 = looping, 3 = done */
      42                 :            :   int step;
      43                 :            :   gss_name_t service;
      44                 :            :   gss_ctx_id_t context;
      45                 :            :   gss_OID mech_oid;
      46                 :            :   gss_buffer_desc token;
      47                 :            :   struct gss_channel_bindings_struct cb;
      48                 :            : };
      49                 :            : typedef struct _gsasl_gs2_client_state _gsasl_gs2_client_state;
      50                 :            : 
      51                 :            : /* Initialize GS2 state into MECH_DATA.  Return GSASL_OK if GS2 is
      52                 :            :    ready and initialization succeeded, or an error code. */
      53                 :            : int
      54                 :         13 : _gsasl_gs2_client_start (Gsasl_session * sctx, void **mech_data)
      55                 :            : {
      56                 :            :   _gsasl_gs2_client_state *state;
      57                 :            :   int res;
      58                 :            : 
      59                 :         13 :   state = (_gsasl_gs2_client_state *) malloc (sizeof (*state));
      60         [ -  + ]:         13 :   if (state == NULL)
      61                 :          0 :     return GSASL_MALLOC_ERROR;
      62                 :            : 
      63                 :         13 :   res = gs2_get_oid (sctx, &state->mech_oid);
      64         [ -  + ]:         13 :   if (res != GSASL_OK)
      65                 :            :     {
      66                 :          0 :       free (state);
      67                 :          0 :       return res;
      68                 :            :     }
      69                 :            : 
      70                 :         13 :   state->step = 0;
      71                 :         13 :   state->service = GSS_C_NO_NAME;
      72                 :         13 :   state->context = GSS_C_NO_CONTEXT;
      73                 :         13 :   state->token.length = 0;
      74                 :         13 :   state->token.value = NULL;
      75                 :            :   /* The initiator-address-type and acceptor-address-type fields of
      76                 :            :      the GSS-CHANNEL-BINDINGS structure MUST be set to 0.  The
      77                 :            :      initiator-address and acceptor-address fields MUST be the empty
      78                 :            :      string. */
      79                 :         13 :   state->cb.initiator_addrtype = 0;
      80                 :         13 :   state->cb.initiator_address.length = 0;
      81                 :         13 :   state->cb.initiator_address.value = NULL;
      82                 :         13 :   state->cb.acceptor_addrtype = 0;
      83                 :         13 :   state->cb.acceptor_address.length = 0;
      84                 :         13 :   state->cb.acceptor_address.value = NULL;
      85                 :         13 :   state->cb.application_data.length = 0;
      86                 :         13 :   state->cb.application_data.value = NULL;
      87                 :            : 
      88                 :         13 :   *mech_data = state;
      89                 :            : 
      90                 :         13 :   return GSASL_OK;
      91                 :            : }
      92                 :            : 
      93                 :            : /* Return newly allocated copy of STR with all occurrences of ','
      94                 :            :    replaced with =2C and '=' with '=3D', or return NULL on memory
      95                 :            :    allocation errors.  */
      96                 :            : static char *
      97                 :          4 : escape_authzid (const char *str)
      98                 :            : {
      99                 :          4 :   char *out = malloc (strlen (str) * 3 + 1);
     100                 :          4 :   char *p = out;
     101                 :            : 
     102         [ -  + ]:          4 :   if (!out)
     103                 :          0 :     return NULL;
     104                 :            : 
     105         [ +  + ]:         19 :   while (*str)
     106                 :            :     {
     107         [ +  + ]:         15 :       if (*str == ',')
     108                 :            :         {
     109                 :          3 :           memcpy (p, "=2C", 3);
     110                 :          3 :           p += 3;
     111                 :            :         }
     112         [ +  + ]:         12 :       else if (*str == '=')
     113                 :            :         {
     114                 :          3 :           memcpy (p, "=3D", 3);
     115                 :          3 :           p += 3;
     116                 :            :         }
     117                 :            :       else
     118                 :            :         {
     119                 :          9 :           *p = *str;
     120                 :          9 :           p++;
     121                 :            :         }
     122                 :         15 :       str++;
     123                 :            :     }
     124                 :          4 :   *p = '\0';
     125                 :            : 
     126                 :          4 :   return out;
     127                 :            : }
     128                 :            : 
     129                 :            : /* Get service, hostname and authorization identity from application,
     130                 :            :    import the GSS-API name, and initialize the channel binding data.
     131                 :            :    Return GSASL_OK on success or an error code. */
     132                 :            : static int
     133                 :         10 : prepare (Gsasl_session * sctx, _gsasl_gs2_client_state * state)
     134                 :            : {
     135                 :         10 :   const char *service = gsasl_property_get (sctx, GSASL_SERVICE);
     136                 :         10 :   const char *hostname = gsasl_property_get (sctx, GSASL_HOSTNAME);
     137                 :         10 :   const char *authzid = gsasl_property_get (sctx, GSASL_AUTHZID);
     138                 :            :   gss_buffer_desc bufdesc;
     139                 :            :   OM_uint32 maj_stat, min_stat;
     140                 :            : 
     141         [ +  + ]:         10 :   if (!service)
     142                 :          5 :     return GSASL_NO_SERVICE;
     143         [ -  + ]:          5 :   if (!hostname)
     144                 :          0 :     return GSASL_NO_HOSTNAME;
     145                 :            : 
     146                 :          5 :   bufdesc.length = asprintf ((char **) &bufdesc.value, "%s@%s",
     147                 :            :                              service, hostname);
     148   [ +  -  -  + ]:          5 :   if (bufdesc.length <= 0 || bufdesc.value == NULL)
     149                 :          0 :     return GSASL_MALLOC_ERROR;
     150                 :            : 
     151                 :          5 :   maj_stat = gss_import_name (&min_stat, &bufdesc,
     152                 :            :                               GSS_C_NT_HOSTBASED_SERVICE, &state->service);
     153                 :          5 :   free (bufdesc.value);
     154         [ -  + ]:          5 :   if (GSS_ERROR (maj_stat))
     155                 :          0 :     return GSASL_GSSAPI_IMPORT_NAME_ERROR;
     156                 :            : 
     157         [ +  + ]:          5 :   if (authzid)
     158                 :            :     {
     159                 :          4 :       char *escaped_authzid = escape_authzid (authzid);
     160                 :            : 
     161         [ -  + ]:          4 :       if (!escaped_authzid)
     162                 :          0 :         return GSASL_MALLOC_ERROR;
     163                 :            : 
     164                 :          4 :       state->cb.application_data.length
     165                 :          4 :         = asprintf ((char **) &state->cb.application_data.value,
     166                 :            :                     "n,a=%s,", escaped_authzid);
     167                 :            : 
     168                 :          4 :       free (escaped_authzid);
     169                 :            :     }
     170                 :            :   else
     171                 :            :     {
     172                 :          1 :       state->cb.application_data.value = strdup ("n,,");
     173                 :          1 :       state->cb.application_data.length = 3;
     174                 :            :     }
     175                 :            : 
     176 [ +  - ][ -  + ]:          5 :   if (state->cb.application_data.length <= 0
     177                 :         10 :       || state->cb.application_data.value == NULL)
     178                 :          0 :     return GSASL_MALLOC_ERROR;
     179                 :            : 
     180                 :         10 :   return GSASL_OK;
     181                 :            : }
     182                 :            : 
     183                 :            : /* Copy token to output buffer.  On first round trip, strip context
     184                 :            :    token header and add channel binding data. For later round trips,
     185                 :            :    just copy the buffer.  Return GSASL_OK on success or an error
     186                 :            :    code.  */
     187                 :            : static int
     188                 :         10 : token2output (Gsasl_session * sctx,
     189                 :            :               _gsasl_gs2_client_state * state,
     190                 :            :               const gss_buffer_t token, char **output, size_t * output_len)
     191                 :            : {
     192                 :            :   OM_uint32 maj_stat, min_stat;
     193                 :            :   gss_buffer_desc bufdesc;
     194                 :            : 
     195         [ +  + ]:         10 :   if (state->step == 1)
     196                 :            :     {
     197                 :          5 :       state->step++;
     198                 :            : 
     199                 :          5 :       maj_stat = gss_decapsulate_token (token, state->mech_oid, &bufdesc);
     200         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     201                 :          0 :         return GSASL_GSSAPI_ENCAPSULATE_TOKEN_ERROR;
     202                 :            : 
     203                 :          5 :       *output_len = state->cb.application_data.length + bufdesc.length;
     204                 :          5 :       *output = malloc (*output_len);
     205         [ -  + ]:          5 :       if (!*output)
     206                 :            :         {
     207                 :          0 :           gss_release_buffer (&min_stat, &bufdesc);
     208                 :          0 :           return GSASL_MALLOC_ERROR;
     209                 :            :         }
     210                 :            : 
     211                 :          5 :       memcpy (*output, state->cb.application_data.value,
     212                 :            :               state->cb.application_data.length);
     213                 :         10 :       memcpy (*output + state->cb.application_data.length,
     214                 :          5 :               bufdesc.value, bufdesc.length);
     215                 :            : 
     216                 :          5 :       maj_stat = gss_release_buffer (&min_stat, &bufdesc);
     217         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     218                 :          0 :         return GSASL_GSSAPI_RELEASE_BUFFER_ERROR;
     219                 :            :     }
     220                 :            :   else
     221                 :            :     {
     222                 :          5 :       *output_len = token->length;
     223                 :          5 :       *output = malloc (*output_len);
     224         [ -  + ]:          5 :       if (!*output)
     225                 :          0 :         return GSASL_MALLOC_ERROR;
     226                 :          5 :       memcpy (*output, token->value, token->length);
     227                 :            :     }
     228                 :            : 
     229                 :         10 :   return GSASL_OK;
     230                 :            : }
     231                 :            : 
     232                 :            : /* Perform one GS2 step.  GS2 state is in MECH_DATA.  Any data from
     233                 :            :    server is provided in INPUT/INPUT_LEN and output from client is
     234                 :            :    expected to be put in newly allocated OUTPUT/OUTPUT_LEN.  Return
     235                 :            :    GSASL_NEEDS_MORE or GSASL_OK on success, or an error code.  */
     236                 :            : int
     237                 :         15 : _gsasl_gs2_client_step (Gsasl_session * sctx,
     238                 :            :                         void *mech_data,
     239                 :            :                         const char *input, size_t input_len,
     240                 :            :                         char **output, size_t * output_len)
     241                 :            : {
     242                 :         15 :   _gsasl_gs2_client_state *state = mech_data;
     243                 :            :   gss_buffer_desc bufdesc;
     244                 :         15 :   gss_buffer_t buf = GSS_C_NO_BUFFER;
     245                 :            :   OM_uint32 maj_stat, min_stat, ret_flags;
     246                 :            :   gss_OID actual_mech_type;
     247                 :            :   int res;
     248                 :            : 
     249         [ -  + ]:         15 :   if (state->step > 2)
     250                 :          0 :     return GSASL_MECHANISM_CALLED_TOO_MANY_TIMES;
     251                 :            : 
     252         [ +  + ]:         15 :   if (state->step == 0)
     253                 :            :     {
     254                 :         10 :       res = prepare (sctx, state);
     255         [ +  + ]:         10 :       if (res != GSASL_OK)
     256                 :          5 :         return res;
     257                 :          5 :       state->step++;
     258                 :            :     }
     259                 :            : 
     260         [ +  + ]:         10 :   if (state->step == 2)
     261                 :            :     {
     262                 :          5 :       bufdesc.length = input_len;
     263                 :          5 :       bufdesc.value = (void *) input;
     264                 :          5 :       buf = &bufdesc;
     265                 :            :     }
     266                 :            : 
     267                 :            :   /* First release memory for token from last round-trip, if any. */
     268         [ +  + ]:         10 :   if (state->token.value != NULL)
     269                 :            :     {
     270                 :          5 :       maj_stat = gss_release_buffer (&min_stat, &state->token);
     271         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     272                 :          0 :         return GSASL_GSSAPI_RELEASE_BUFFER_ERROR;
     273                 :            : 
     274                 :          5 :       state->token.value = NULL;
     275                 :          5 :       state->token.length = 0;
     276                 :            :     }
     277                 :            : 
     278                 :         10 :   maj_stat = gss_init_sec_context (&min_stat,
     279                 :            :                                    GSS_C_NO_CREDENTIAL,
     280                 :            :                                    &state->context,
     281                 :            :                                    state->service,
     282                 :            :                                    state->mech_oid,
     283                 :            :                                    GSS_C_MUTUAL_FLAG,
     284                 :            :                                    0,
     285                 :            :                                    &state->cb,
     286                 :            :                                    buf,
     287                 :            :                                    &actual_mech_type,
     288                 :         10 :                                    &state->token, &ret_flags, NULL);
     289   [ +  +  -  + ]:         10 :   if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
     290                 :          0 :     return GSASL_GSSAPI_INIT_SEC_CONTEXT_ERROR;
     291                 :            : 
     292                 :         10 :   res = token2output (sctx, state, &state->token, output, output_len);
     293         [ -  + ]:         10 :   if (res != GSASL_OK)
     294                 :          0 :     return res;
     295                 :            : 
     296         [ +  + ]:         10 :   if (maj_stat == GSS_S_CONTINUE_NEEDED)
     297                 :          5 :     return GSASL_NEEDS_MORE;
     298                 :            : 
     299                 :            :   /* The GSS-API layer is done here, check that we established a valid
     300                 :            :      security context for GS2 purposes. */
     301                 :            : 
     302         [ -  + ]:          5 :   if (!(ret_flags & GSS_C_MUTUAL_FLAG))
     303                 :          0 :     return GSASL_AUTHENTICATION_ERROR;
     304                 :            : 
     305         [ -  + ]:          5 :   if (!gss_oid_equal (state->mech_oid, actual_mech_type))
     306                 :          0 :     return GSASL_AUTHENTICATION_ERROR;
     307                 :            : 
     308                 :          5 :   state->step++;
     309                 :         15 :   return GSASL_OK;
     310                 :            : }
     311                 :            : 
     312                 :            : /* Cleanup GS2 state context, i.e., release memory associated with
     313                 :            :    buffers in MECH_DATA state. */
     314                 :            : void
     315                 :         13 : _gsasl_gs2_client_finish (Gsasl_session * sctx, void *mech_data)
     316                 :            : {
     317                 :         13 :   _gsasl_gs2_client_state *state = mech_data;
     318                 :            :   OM_uint32 maj_stat, min_stat;
     319                 :            : 
     320         [ -  + ]:         13 :   if (!state)
     321                 :          0 :     return;
     322                 :            : 
     323         [ -  + ]:         13 :   if (state->token.value != NULL)
     324                 :          0 :     maj_stat = gss_release_buffer (&min_stat, &state->token);
     325         [ +  + ]:         13 :   if (state->service != GSS_C_NO_NAME)
     326                 :          5 :     maj_stat = gss_release_name (&min_stat, &state->service);
     327         [ +  + ]:         13 :   if (state->context != GSS_C_NO_CONTEXT)
     328                 :          5 :     maj_stat = gss_delete_sec_context (&min_stat, &state->context,
     329                 :            :                                        GSS_C_NO_BUFFER);
     330                 :            : 
     331                 :         13 :   free (state->cb.application_data.value);
     332                 :         13 :   free (state);
     333                 :            : }

Generated by: LCOV version 1.8