LCOV - code coverage report
Current view: top level - lib/gssapi - client.c (source / functions) Hit Total Coverage
Test: GNU SASL Lines: 82 152 53.9 %
Date: 2010-09-27 Functions: 3 5 60.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 31 76 40.8 %

           Branch data     Line data    Source code
       1                 :            : /* client.c --- SASL mechanism GSSAPI as defined in RFC 4752, client side.
       2                 :            :  * Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 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 malloc, free. */
      28                 :            : #include <stdlib.h>
      29                 :            : 
      30                 :            : /* Get memcpy, strlen. */
      31                 :            : #include <string.h>
      32                 :            : 
      33                 :            : /* Get specification. */
      34                 :            : #include "x-gssapi.h"
      35                 :            : 
      36                 :            : #ifdef HAVE_LIBGSS
      37                 :            : # include <gss.h>
      38                 :            : #elif HAVE_GSSAPI_H
      39                 :            : # include <gssapi.h>
      40                 :            : #elif HAVE_GSSAPI_GSSAPI_H
      41                 :            : # include <gssapi/gssapi.h>
      42                 :            : #endif
      43                 :            : 
      44                 :            : #include "gss-extra.h"
      45                 :            : 
      46                 :            : struct _Gsasl_gssapi_client_state
      47                 :            : {
      48                 :            :   int step;
      49                 :            :   gss_name_t service;
      50                 :            :   gss_ctx_id_t context;
      51                 :            :   gss_qop_t qop;
      52                 :            : };
      53                 :            : typedef struct _Gsasl_gssapi_client_state _Gsasl_gssapi_client_state;
      54                 :            : 
      55                 :            : int
      56                 :         13 : _gsasl_gssapi_client_start (Gsasl_session * sctx, void **mech_data)
      57                 :            : {
      58                 :            :   _Gsasl_gssapi_client_state *state;
      59                 :            : 
      60                 :         13 :   state = (_Gsasl_gssapi_client_state *) malloc (sizeof (*state));
      61         [ -  + ]:         13 :   if (state == NULL)
      62                 :          0 :     return GSASL_MALLOC_ERROR;
      63                 :            : 
      64                 :         13 :   state->context = GSS_C_NO_CONTEXT;
      65                 :         13 :   state->service = GSS_C_NO_NAME;
      66                 :         13 :   state->step = 0;
      67                 :         13 :   state->qop = GSASL_QOP_AUTH;       /* FIXME: Should be GSASL_QOP_AUTH_CONF. */
      68                 :            : 
      69                 :         13 :   *mech_data = state;
      70                 :            : 
      71                 :         13 :   return GSASL_OK;
      72                 :            : }
      73                 :            : 
      74                 :            : int
      75                 :         20 : _gsasl_gssapi_client_step (Gsasl_session * sctx,
      76                 :            :                            void *mech_data,
      77                 :            :                            const char *input, size_t input_len,
      78                 :            :                            char **output, size_t * output_len)
      79                 :            : {
      80                 :         20 :   _Gsasl_gssapi_client_state *state = mech_data;
      81                 :            :   char clientwrap[4];
      82                 :            :   gss_qop_t serverqop;
      83                 :            :   gss_buffer_desc bufdesc, bufdesc2;
      84                 :         20 :   gss_buffer_t buf = GSS_C_NO_BUFFER;
      85                 :            :   OM_uint32 maj_stat, min_stat;
      86                 :            :   int conf_state;
      87                 :            :   int res;
      88                 :            :   const char *p;
      89                 :            : 
      90         [ +  + ]:         20 :   if (state->service == NULL)
      91                 :            :     {
      92                 :            :       const char *service, *hostname;
      93                 :            : 
      94                 :         10 :       service = gsasl_property_get (sctx, GSASL_SERVICE);
      95         [ +  + ]:         10 :       if (!service)
      96                 :          5 :         return GSASL_NO_SERVICE;
      97                 :            : 
      98                 :          5 :       hostname = gsasl_property_get (sctx, GSASL_HOSTNAME);
      99         [ -  + ]:          5 :       if (!hostname)
     100                 :          0 :         return GSASL_NO_HOSTNAME;
     101                 :            : 
     102                 :            :       /* FIXME: Use asprintf. */
     103                 :            : 
     104                 :          5 :       bufdesc.length = strlen (service) + 1 + strlen (hostname) + 1;
     105                 :          5 :       bufdesc.value = malloc (bufdesc.length);
     106         [ -  + ]:          5 :       if (bufdesc.value == NULL)
     107                 :          0 :         return GSASL_MALLOC_ERROR;
     108                 :            : 
     109                 :          5 :       sprintf (bufdesc.value, "%s@%s", service, hostname);
     110                 :            : 
     111                 :          5 :       maj_stat = gss_import_name (&min_stat, &bufdesc,
     112                 :            :                                   GSS_C_NT_HOSTBASED_SERVICE,
     113                 :            :                                   &state->service);
     114                 :          5 :       free (bufdesc.value);
     115         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     116                 :          0 :         return GSASL_GSSAPI_IMPORT_NAME_ERROR;
     117                 :            :     }
     118                 :            : 
     119   [ +  +  +  - ]:         15 :   switch (state->step)
     120                 :            :     {
     121                 :            :     case 1:
     122                 :          5 :       bufdesc.length = input_len;
     123                 :          5 :       bufdesc.value = (void *) input;
     124                 :          5 :       buf = &bufdesc;
     125                 :            :       /* fall through */
     126                 :            : 
     127                 :            :     case 0:
     128                 :         10 :       bufdesc2.length = 0;
     129                 :         10 :       bufdesc2.value = NULL;
     130                 :         10 :       maj_stat = gss_init_sec_context (&min_stat,
     131                 :            :                                        GSS_C_NO_CREDENTIAL,
     132                 :            :                                        &state->context,
     133                 :            :                                        state->service,
     134                 :            :                                        GSS_C_NO_OID,
     135                 :            :                                        GSS_C_MUTUAL_FLAG |
     136                 :            :                                        GSS_C_REPLAY_FLAG |
     137                 :            :                                        GSS_C_SEQUENCE_FLAG |
     138                 :            :                                        GSS_C_INTEG_FLAG |
     139                 :            :                                        GSS_C_CONF_FLAG,
     140                 :            :                                        0,
     141                 :            :                                        GSS_C_NO_CHANNEL_BINDINGS,
     142                 :            :                                        buf, NULL, &bufdesc2, NULL, NULL);
     143   [ +  +  -  + ]:         10 :       if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
     144                 :          0 :         return GSASL_GSSAPI_INIT_SEC_CONTEXT_ERROR;
     145                 :            : 
     146                 :         10 :       *output_len = bufdesc2.length;
     147                 :         10 :       *output = malloc (*output_len);
     148         [ -  + ]:         10 :       if (!*output)
     149                 :          0 :         return GSASL_MALLOC_ERROR;
     150                 :         10 :       memcpy (*output, bufdesc2.value, bufdesc2.length);
     151                 :            : 
     152         [ +  + ]:         10 :       if (maj_stat == GSS_S_COMPLETE)
     153                 :          5 :         state->step = 2;
     154                 :            :       else
     155                 :          5 :         state->step = 1;
     156                 :            : 
     157                 :         10 :       maj_stat = gss_release_buffer (&min_stat, &bufdesc2);
     158         [ -  + ]:         10 :       if (maj_stat != GSS_S_COMPLETE)
     159                 :          0 :         return GSASL_GSSAPI_RELEASE_BUFFER_ERROR;
     160                 :            : 
     161                 :         10 :       res = GSASL_NEEDS_MORE;
     162                 :         10 :       break;
     163                 :            : 
     164                 :            :     case 2:
     165                 :            :       /* [RFC 2222 section 7.2.1]:
     166                 :            :          The client passes this token to GSS_Unwrap and interprets the
     167                 :            :          first octet of resulting cleartext as a bit-mask specifying
     168                 :            :          the security layers supported by the server and the second
     169                 :            :          through fourth octets as the maximum size output_message to
     170                 :            :          send to the server.  The client then constructs data, with
     171                 :            :          the first octet containing the bit-mask specifying the
     172                 :            :          selected security layer, the second through fourth octets
     173                 :            :          containing in network byte order the maximum size
     174                 :            :          output_message the client is able to receive, and the
     175                 :            :          remaining octets containing the authorization identity.  The
     176                 :            :          client passes the data to GSS_Wrap with conf_flag set to
     177                 :            :          FALSE, and responds with the generated output_message.  The
     178                 :            :          client can then consider the server authenticated. */
     179                 :            : 
     180                 :          5 :       bufdesc.length = input_len;
     181                 :          5 :       bufdesc.value = (void *) input;
     182                 :          5 :       maj_stat = gss_unwrap (&min_stat, state->context, &bufdesc,
     183                 :            :                              &bufdesc2, &conf_state, &serverqop);
     184         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     185                 :          0 :         return GSASL_GSSAPI_UNWRAP_ERROR;
     186                 :            : 
     187         [ -  + ]:          5 :       if (bufdesc2.length != 4)
     188                 :          0 :         return GSASL_MECHANISM_PARSE_ERROR;
     189                 :            : 
     190                 :          5 :       memcpy (clientwrap, bufdesc2.value, 4);
     191                 :            : 
     192                 :          5 :       maj_stat = gss_release_buffer (&min_stat, &bufdesc2);
     193         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     194                 :          0 :         return GSASL_GSSAPI_RELEASE_BUFFER_ERROR;
     195                 :            : 
     196                 :            : #if 0
     197                 :            :       /* FIXME: Fix qop. */
     198                 :            :       if (cb_qop)
     199                 :            :         state->qop = cb_qop (sctx, serverqop);
     200                 :            : 
     201                 :            :       if ((state->qop & serverqop) == 0)
     202                 :            :         /*  Server does not support what user wanted. */
     203                 :            :         return GSASL_GSSAPI_UNSUPPORTED_PROTECTION_ERROR;
     204                 :            : #endif
     205                 :            : 
     206                 :            :       /* FIXME: Fix maxbuf. */
     207                 :            : 
     208                 :          5 :       p = gsasl_property_get (sctx, GSASL_AUTHID);
     209         [ -  + ]:          5 :       if (!p)
     210                 :          0 :         return GSASL_NO_AUTHID;
     211                 :            : 
     212                 :          5 :       bufdesc.length = 4 + strlen (p);
     213                 :          5 :       bufdesc.value = malloc (bufdesc.length);
     214         [ -  + ]:          5 :       if (!bufdesc.value)
     215                 :          0 :         return GSASL_MALLOC_ERROR;
     216                 :            : 
     217                 :            :       {
     218                 :          5 :         char *q = bufdesc.value;
     219                 :          5 :         q[0] = state->qop;
     220                 :          5 :         memcpy (q + 1, clientwrap + 1, 3);
     221                 :          5 :         memcpy (q + 4, p, strlen (p));
     222                 :            :       }
     223                 :            : 
     224                 :          5 :       maj_stat = gss_wrap (&min_stat, state->context, 0, GSS_C_QOP_DEFAULT,
     225                 :            :                            &bufdesc, &conf_state, &bufdesc2);
     226                 :          5 :       free (bufdesc.value);
     227         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     228                 :          0 :         return GSASL_GSSAPI_WRAP_ERROR;
     229                 :            : 
     230                 :          5 :       *output_len = bufdesc2.length;
     231                 :          5 :       *output = malloc (bufdesc2.length);
     232         [ -  + ]:          5 :       if (!*output)
     233                 :          0 :         return GSASL_MALLOC_ERROR;
     234                 :            : 
     235                 :          5 :       memcpy (*output, bufdesc2.value, bufdesc2.length);
     236                 :            : 
     237                 :          5 :       maj_stat = gss_release_buffer (&min_stat, &bufdesc2);
     238         [ -  + ]:          5 :       if (GSS_ERROR (maj_stat))
     239                 :          0 :         return GSASL_GSSAPI_RELEASE_BUFFER_ERROR;
     240                 :            : 
     241                 :          5 :       state->step++;
     242                 :          5 :       res = GSASL_OK;
     243                 :          5 :       break;
     244                 :            : 
     245                 :            :     default:
     246                 :          0 :       res = GSASL_MECHANISM_CALLED_TOO_MANY_TIMES;
     247                 :            :       break;
     248                 :            :     }
     249                 :            : 
     250                 :         20 :   return res;
     251                 :            : }
     252                 :            : 
     253                 :            : void
     254                 :         13 : _gsasl_gssapi_client_finish (Gsasl_session * sctx, void *mech_data)
     255                 :            : {
     256                 :         13 :   _Gsasl_gssapi_client_state *state = mech_data;
     257                 :            :   OM_uint32 maj_stat, min_stat;
     258                 :            : 
     259         [ -  + ]:         13 :   if (!state)
     260                 :          0 :     return;
     261                 :            : 
     262         [ +  + ]:         13 :   if (state->service != GSS_C_NO_NAME)
     263                 :          5 :     maj_stat = gss_release_name (&min_stat, &state->service);
     264         [ +  + ]:         13 :   if (state->context != GSS_C_NO_CONTEXT)
     265                 :          5 :     maj_stat = gss_delete_sec_context (&min_stat, &state->context,
     266                 :            :                                        GSS_C_NO_BUFFER);
     267                 :            : 
     268                 :         13 :   free (state);
     269                 :            : }
     270                 :            : 
     271                 :            : int
     272                 :          0 : _gsasl_gssapi_client_encode (Gsasl_session * sctx,
     273                 :            :                              void *mech_data,
     274                 :            :                              const char *input, size_t input_len,
     275                 :            :                              char **output, size_t * output_len)
     276                 :            : {
     277                 :          0 :   _Gsasl_gssapi_client_state *state = mech_data;
     278                 :            :   OM_uint32 min_stat, maj_stat;
     279                 :            :   gss_buffer_desc foo;
     280                 :          0 :   gss_buffer_t input_message_buffer = &foo;
     281                 :            :   gss_buffer_desc output_message_buffer;
     282                 :            : 
     283                 :          0 :   foo.length = input_len;
     284                 :          0 :   foo.value = (void *) input;
     285                 :            : 
     286 [ #  # ][ #  # ]:          0 :   if (state && state->step == 3 &&
                 [ #  # ]
     287                 :          0 :       state->qop & (GSASL_QOP_AUTH_INT | GSASL_QOP_AUTH_CONF))
     288                 :            :     {
     289                 :          0 :       maj_stat = gss_wrap (&min_stat,
     290                 :            :                            state->context,
     291                 :          0 :                            state->qop & GSASL_QOP_AUTH_CONF ? 1 : 0,
     292                 :            :                            GSS_C_QOP_DEFAULT,
     293                 :            :                            input_message_buffer,
     294                 :            :                            NULL, &output_message_buffer);
     295         [ #  # ]:          0 :       if (GSS_ERROR (maj_stat))
     296                 :          0 :         return GSASL_GSSAPI_WRAP_ERROR;
     297                 :          0 :       *output_len = output_message_buffer.length;
     298                 :          0 :       *output = malloc (input_len);
     299         [ #  # ]:          0 :       if (!*output)
     300                 :            :         {
     301                 :          0 :           maj_stat = gss_release_buffer (&min_stat, &output_message_buffer);
     302                 :          0 :           return GSASL_MALLOC_ERROR;
     303                 :            :         }
     304                 :          0 :       memcpy (*output, output_message_buffer.value,
     305                 :            :               output_message_buffer.length);
     306                 :            : 
     307                 :          0 :       maj_stat = gss_release_buffer (&min_stat, &output_message_buffer);
     308         [ #  # ]:          0 :       if (GSS_ERROR (maj_stat))
     309                 :            :         {
     310                 :          0 :           free (*output);
     311                 :          0 :           return GSASL_GSSAPI_RELEASE_BUFFER_ERROR;
     312                 :            :         }
     313                 :            :     }
     314                 :            :   else
     315                 :            :     {
     316                 :          0 :       *output_len = input_len;
     317                 :          0 :       *output = malloc (input_len);
     318         [ #  # ]:          0 :       if (!*output)
     319                 :          0 :         return GSASL_MALLOC_ERROR;
     320                 :          0 :       memcpy (*output, input, input_len);
     321                 :            :     }
     322                 :            : 
     323                 :          0 :   return GSASL_OK;
     324                 :            : }
     325                 :            : 
     326                 :            : int
     327                 :          0 : _gsasl_gssapi_client_decode (Gsasl_session * sctx,
     328                 :            :                              void *mech_data,
     329                 :            :                              const char *input, size_t input_len,
     330                 :            :                              char **output, size_t * output_len)
     331                 :            : {
     332                 :          0 :   _Gsasl_gssapi_client_state *state = mech_data;
     333                 :            :   OM_uint32 min_stat, maj_stat;
     334                 :            :   gss_buffer_desc foo;
     335                 :          0 :   gss_buffer_t input_message_buffer = &foo;
     336                 :            :   gss_buffer_desc output_message_buffer;
     337                 :            : 
     338                 :          0 :   foo.length = input_len;
     339                 :          0 :   foo.value = (void *) input;
     340                 :            : 
     341 [ #  # ][ #  # ]:          0 :   if (state && state->step == 3 &&
                 [ #  # ]
     342                 :          0 :       state->qop & (GSASL_QOP_AUTH_INT | GSASL_QOP_AUTH_CONF))
     343                 :            :     {
     344                 :          0 :       maj_stat = gss_unwrap (&min_stat,
     345                 :            :                              state->context,
     346                 :            :                              input_message_buffer,
     347                 :            :                              &output_message_buffer, NULL, NULL);
     348         [ #  # ]:          0 :       if (GSS_ERROR (maj_stat))
     349                 :          0 :         return GSASL_GSSAPI_UNWRAP_ERROR;
     350                 :          0 :       *output_len = output_message_buffer.length;
     351                 :          0 :       *output = malloc (input_len);
     352         [ #  # ]:          0 :       if (!*output)
     353                 :            :         {
     354                 :          0 :           maj_stat = gss_release_buffer (&min_stat, &output_message_buffer);
     355                 :          0 :           return GSASL_MALLOC_ERROR;
     356                 :            :         }
     357                 :          0 :       memcpy (*output, output_message_buffer.value,
     358                 :            :               output_message_buffer.length);
     359                 :            : 
     360                 :          0 :       maj_stat = gss_release_buffer (&min_stat, &output_message_buffer);
     361         [ #  # ]:          0 :       if (GSS_ERROR (maj_stat))
     362                 :            :         {
     363                 :          0 :           free (*output);
     364                 :          0 :           return GSASL_GSSAPI_RELEASE_BUFFER_ERROR;
     365                 :            :         }
     366                 :            :     }
     367                 :            :   else
     368                 :            :     {
     369                 :          0 :       *output_len = input_len;
     370                 :          0 :       *output = malloc (input_len);
     371         [ #  # ]:          0 :       if (!*output)
     372                 :          0 :         return GSASL_MALLOC_ERROR;
     373                 :          0 :       memcpy (*output, input, input_len);
     374                 :            :     }
     375                 :            : 
     376                 :          0 :   return GSASL_OK;
     377                 :            : }

Generated by: LCOV version 1.8