LCOV - code coverage report
Current view: top level - lib/krb5 - msg.c (source / functions) Hit Total Coverage
Test: GNU Generic Security Service Lines: 89 211 42.2 %
Date: 2010-05-20 Functions: 2 4 50.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 33 124 26.6 %

           Branch data     Line data    Source code
       1                 :            : /* krb5/msg.c --- Implementation of Kerberos 5 GSS-API Per-Message functions.
       2                 :            :  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010  Simon Josefsson
       3                 :            :  *
       4                 :            :  * This file is part of the Generic Security Service (GSS).
       5                 :            :  *
       6                 :            :  * GSS is free software; you can redistribute it and/or modify it
       7                 :            :  * under the terms of the GNU General Public License as published by
       8                 :            :  * the Free Software Foundation; either version 3 of the License, or
       9                 :            :  * (at your option) any later version.
      10                 :            :  *
      11                 :            :  * GSS is distributed in the hope that it will be useful, but WITHOUT
      12                 :            :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      13                 :            :  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      14                 :            :  * License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU General Public License
      17                 :            :  * along with GSS; if not, see http://www.gnu.org/licenses or write to
      18                 :            :  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth
      19                 :            :  * Floor, Boston, MA 02110-1301, USA.
      20                 :            :  *
      21                 :            :  */
      22                 :            : 
      23                 :            : /* Get specification. */
      24                 :            : #include "k5internal.h"
      25                 :            : 
      26                 :            : #define TOK_LEN 2
      27                 :            : #define TOK_WRAP   "\x02\x01"
      28                 :            : 
      29                 :            : #define C2I(buf) ((buf[0] & 0xFF) |         \
      30                 :            :                   ((buf[1] & 0xFF) << 8) |    \
      31                 :            :                   ((buf[2] & 0xFF) << 16) |   \
      32                 :            :                   ((buf[3] & 0xFF) << 24))
      33                 :            : 
      34                 :            : OM_uint32
      35                 :          0 : gss_krb5_get_mic (OM_uint32 * minor_status,
      36                 :            :                   const gss_ctx_id_t context_handle,
      37                 :            :                   gss_qop_t qop_req,
      38                 :            :                   const gss_buffer_t message_buffer,
      39                 :            :                   gss_buffer_t message_token)
      40                 :            : {
      41                 :          0 :   return GSS_S_UNAVAILABLE;
      42                 :            : }
      43                 :            : 
      44                 :            : OM_uint32
      45                 :          0 : gss_krb5_verify_mic (OM_uint32 * minor_status,
      46                 :            :                      const gss_ctx_id_t context_handle,
      47                 :            :                      const gss_buffer_t message_buffer,
      48                 :            :                      const gss_buffer_t token_buffer, gss_qop_t * qop_state)
      49                 :            : {
      50                 :          0 :   return GSS_S_UNAVAILABLE;
      51                 :            : }
      52                 :            : 
      53                 :            : OM_uint32
      54                 :          3 : gss_krb5_wrap (OM_uint32 * minor_status,
      55                 :            :                const gss_ctx_id_t context_handle,
      56                 :            :                int conf_req_flag,
      57                 :            :                gss_qop_t qop_req,
      58                 :            :                const gss_buffer_t input_message_buffer,
      59                 :            :                int *conf_state, gss_buffer_t output_message_buffer)
      60                 :            : {
      61                 :          3 :   _gss_krb5_ctx_t k5 = context_handle->krb5;
      62                 :            :   size_t padlength;
      63                 :            :   gss_buffer_desc data;
      64                 :            :   char *p;
      65                 :            :   size_t tmplen;
      66                 :            :   int rc;
      67                 :            : 
      68      [ +  -  - ]:          3 :   switch (shishi_key_type (k5->key))
      69                 :            :     {
      70                 :            :       /* XXX implement other checksums */
      71                 :            : 
      72                 :            :     case SHISHI_DES_CBC_MD5:
      73                 :            :       {
      74                 :            :         char header[8];
      75                 :            :         char seqno[8];
      76                 :            :         char *eseqno;
      77                 :            :         char *cksum;
      78                 :            :         char confounder[8];
      79                 :            : 
      80                 :            :         /* Typical data:
      81                 :            :            ;; 02 01 00 00 ff ff ff ff  0c 22 1f 79 59 3d 00 cb
      82                 :            :            ;; d5 78 2f fb 50 d2 b8 59  fb b4 e0 9b d0 a2 fa dc
      83                 :            :            ;; 01 00 20 00 04 04 04 04
      84                 :            :            Translates into:
      85                 :            :            ;;   HEADER                 ENCRYPTED SEQ.NUMBER
      86                 :            :            ;;   DES-MAC-MD5 CKSUM      CONFOUNDER
      87                 :            :            ;;   PADDED DATA
      88                 :            :          */
      89                 :          3 :         padlength = 8 - input_message_buffer->length % 8;
      90                 :          3 :         data.length = 4 * 8 + input_message_buffer->length + padlength;
      91                 :          3 :         p = malloc (data.length);
      92         [ -  + ]:          3 :         if (!p)
      93                 :            :           {
      94         [ #  # ]:          0 :             if (minor_status)
      95                 :          0 :               *minor_status = ENOMEM;
      96                 :          0 :             return GSS_S_FAILURE;
      97                 :            :           }
      98                 :            : 
      99                 :            :         /* XXX encrypt data iff confidential option chosen */
     100                 :            : 
     101                 :            :         /* Setup header and confounder */
     102                 :          3 :         memcpy (header, TOK_WRAP, 2);   /* TOK_ID: Wrap 0201 */
     103                 :          3 :         memcpy (header + 2, "\x00\x00", 2);   /* SGN_ALG: DES-MAC-MD5 */
     104                 :          3 :         memcpy (header + 4, "\xFF\xFF", 2);   /* SEAL_ALG: none */
     105                 :          3 :         memcpy (header + 6, "\xFF\xFF", 2);   /* filler */
     106                 :          3 :         rc = shishi_randomize (k5->sh, 0, confounder, 8);
     107         [ -  + ]:          3 :         if (rc != SHISHI_OK)
     108                 :          0 :           return GSS_S_FAILURE;
     109                 :            : 
     110                 :            :         /* Compute checksum over header, confounder, input string, and pad */
     111                 :          3 :         memcpy (p, header, 8);
     112                 :          3 :         memcpy (p + 8, confounder, 8);
     113                 :          3 :         memcpy (p + 16, input_message_buffer->value,
     114                 :            :                 input_message_buffer->length);
     115                 :          3 :         memset (p + 16 + input_message_buffer->length,
     116                 :            :                 (int) padlength, padlength);
     117                 :            : 
     118                 :          3 :         rc = shishi_checksum (k5->sh,
     119                 :            :                               k5->key,
     120                 :            :                               0, SHISHI_RSA_MD5_DES_GSS,
     121                 :            :                               p,
     122                 :            :                               16 + input_message_buffer->length + padlength,
     123                 :            :                               &cksum, &tmplen);
     124   [ +  -  -  + ]:          3 :         if (rc != SHISHI_OK || tmplen != 8)
     125                 :          0 :           return GSS_S_FAILURE;
     126                 :            : 
     127                 :            :         /* seq_nr */
     128         [ -  + ]:          3 :         if (k5->acceptor)
     129                 :            :           {
     130                 :          0 :             seqno[0] = k5->acceptseqnr & 0xFF;
     131                 :          0 :             seqno[1] = k5->acceptseqnr >> 8 & 0xFF;
     132                 :          0 :             seqno[2] = k5->acceptseqnr >> 16 & 0xFF;
     133                 :          0 :             seqno[3] = k5->acceptseqnr >> 24 & 0xFF;
     134                 :          0 :             memset (seqno + 4, 0xFF, 4);
     135                 :            :           }
     136                 :            :         else
     137                 :            :           {
     138                 :          3 :             seqno[0] = k5->initseqnr & 0xFF;
     139                 :          3 :             seqno[1] = k5->initseqnr >> 8 & 0xFF;
     140                 :          3 :             seqno[2] = k5->initseqnr >> 16 & 0xFF;
     141                 :          3 :             seqno[3] = k5->initseqnr >> 24 & 0xFF;
     142                 :          3 :             memset (seqno + 4, 0, 4);
     143                 :            :           }
     144                 :            : 
     145                 :          3 :         rc = shishi_encrypt_iv_etype (k5->sh, k5->key, 0,
     146                 :            :                                       SHISHI_DES_CBC_NONE, cksum, 8,
     147                 :            :                                       seqno, 8, &eseqno, &tmplen);
     148   [ +  -  -  + ]:          3 :         if (rc != SHISHI_OK || tmplen != 8)
     149                 :          0 :           return GSS_S_FAILURE;
     150                 :            : 
     151                 :            :         /* put things in place */
     152                 :          3 :         memcpy (p, header, 8);
     153                 :          3 :         memcpy (p + 8, eseqno, 8);
     154                 :          3 :         free (eseqno);
     155                 :          3 :         memcpy (p + 16, cksum, 8);
     156                 :          3 :         free (cksum);
     157                 :          3 :         memcpy (p + 24, confounder, 8);
     158                 :          3 :         memcpy (p + 32, input_message_buffer->value,
     159                 :            :                 input_message_buffer->length);
     160                 :          3 :         memset (p + 32 + input_message_buffer->length,
     161                 :            :                 (int) padlength, padlength);
     162                 :            : 
     163                 :          3 :         data.value = p;
     164                 :            : 
     165                 :          3 :         rc = gss_encapsulate_token (&data, GSS_KRB5, output_message_buffer);
     166         [ -  + ]:          3 :         if (rc != GSS_S_COMPLETE)
     167                 :          0 :           return GSS_S_FAILURE;
     168         [ -  + ]:          3 :         if (k5->acceptor)
     169                 :          0 :           k5->acceptseqnr++;
     170                 :            :         else
     171                 :          3 :           k5->initseqnr++;
     172                 :            :       }
     173                 :          3 :       break;
     174                 :            : 
     175                 :            :     case SHISHI_DES3_CBC_HMAC_SHA1_KD:
     176                 :            :       {
     177                 :            :         char *tmp;
     178                 :            : 
     179                 :          0 :         padlength = 8 - input_message_buffer->length % 8;
     180                 :          0 :         data.length = 8 + 8 + 20 + 8 + input_message_buffer->length
     181                 :            :           + padlength;
     182                 :          0 :         p = malloc (data.length);
     183         [ #  # ]:          0 :         if (!p)
     184                 :            :           {
     185         [ #  # ]:          0 :             if (minor_status)
     186                 :          0 :               *minor_status = ENOMEM;
     187                 :          0 :             return GSS_S_FAILURE;
     188                 :            :           }
     189                 :            : 
     190                 :            :         /* XXX encrypt data iff confidential option chosen */
     191                 :            : 
     192                 :            :         /* Compute checksum over header, confounder, input string, and pad */
     193                 :            : 
     194                 :          0 :         memcpy (p, TOK_WRAP, 2);        /* TOK_ID: Wrap */
     195                 :          0 :         memcpy (p + 2, "\x04\x00", 2);        /* SGN_ALG: 3DES */
     196                 :          0 :         memcpy (p + 4, "\xFF\xFF", 2);        /* SEAL_ALG: none */
     197                 :          0 :         memcpy (p + 6, "\xFF\xFF", 2);        /* filler */
     198                 :          0 :         rc = shishi_randomize (k5->sh, 0, p + 8, 8);
     199         [ #  # ]:          0 :         if (rc != SHISHI_OK)
     200                 :          0 :           return GSS_S_FAILURE;
     201                 :          0 :         memcpy (p + 16, input_message_buffer->value,
     202                 :            :                 input_message_buffer->length);
     203                 :          0 :         memset (p + 16 + input_message_buffer->length,
     204                 :            :                 (int) padlength, padlength);
     205                 :            : 
     206                 :          0 :         rc = shishi_checksum (k5->sh,
     207                 :            :                               k5->key,
     208                 :            :                               SHISHI_KEYUSAGE_GSS_R2,
     209                 :            :                               SHISHI_HMAC_SHA1_DES3_KD, p,
     210                 :            :                               16 + input_message_buffer->length + padlength,
     211                 :            :                               &tmp, &tmplen);
     212   [ #  #  #  # ]:          0 :         if (rc != SHISHI_OK || tmplen != 20)
     213                 :          0 :           return GSS_S_FAILURE;
     214                 :            : 
     215                 :          0 :         memcpy (p + 16, tmp, tmplen);
     216                 :          0 :         memcpy (p + 36, p + 8, 8);
     217                 :            : 
     218                 :            :         /* seq_nr */
     219         [ #  # ]:          0 :         if (k5->acceptor)
     220                 :            :           {
     221                 :          0 :             (p + 8)[0] = k5->acceptseqnr & 0xFF;
     222                 :          0 :             (p + 8)[1] = k5->acceptseqnr >> 8 & 0xFF;
     223                 :          0 :             (p + 8)[2] = k5->acceptseqnr >> 16 & 0xFF;
     224                 :          0 :             (p + 8)[3] = k5->acceptseqnr >> 24 & 0xFF;
     225                 :          0 :             memset (p + 8 + 4, 0xFF, 4);
     226                 :            :           }
     227                 :            :         else
     228                 :            :           {
     229                 :          0 :             (p + 8)[0] = k5->initseqnr & 0xFF;
     230                 :          0 :             (p + 8)[1] = k5->initseqnr >> 8 & 0xFF;
     231                 :          0 :             (p + 8)[2] = k5->initseqnr >> 16 & 0xFF;
     232                 :          0 :             (p + 8)[3] = k5->initseqnr >> 24 & 0xFF;
     233                 :          0 :             memset (p + 8 + 4, 0, 4);
     234                 :            :           }
     235                 :            : 
     236                 :          0 :         rc = shishi_encrypt_iv_etype (k5->sh, k5->key, 0, SHISHI_DES3_CBC_NONE, p + 16, 8,        /* cksum */
     237                 :            :                                       p + 8, 8, &tmp, &tmplen);
     238   [ #  #  #  # ]:          0 :         if (rc != SHISHI_OK || tmplen != 8)
     239                 :          0 :           return GSS_S_FAILURE;
     240                 :            : 
     241                 :          0 :         memcpy (p + 8, tmp, tmplen);
     242                 :          0 :         free (tmp);
     243                 :          0 :         memcpy (p + 8 + 8 + 20 + 8, input_message_buffer->value,
     244                 :            :                 input_message_buffer->length);
     245                 :          0 :         memset (p + 8 + 8 + 20 + 8 + input_message_buffer->length,
     246                 :            :                 (int) padlength, padlength);
     247                 :            : 
     248                 :          0 :         data.value = p;
     249                 :            : 
     250                 :          0 :         rc = gss_encapsulate_token (&data, GSS_KRB5, output_message_buffer);
     251         [ #  # ]:          0 :         if (rc != GSS_S_COMPLETE)
     252                 :          0 :           return GSS_S_FAILURE;
     253         [ #  # ]:          0 :         if (k5->acceptor)
     254                 :          0 :           k5->acceptseqnr++;
     255                 :            :         else
     256                 :          0 :           k5->initseqnr++;
     257                 :          0 :         break;
     258                 :            :       }
     259                 :            : 
     260                 :            :     default:
     261                 :          0 :       return GSS_S_FAILURE;
     262                 :            :     }
     263                 :            : 
     264                 :          3 :   return GSS_S_COMPLETE;
     265                 :            : }
     266                 :            : 
     267                 :            : OM_uint32
     268                 :          3 : gss_krb5_unwrap (OM_uint32 * minor_status,
     269                 :            :                  const gss_ctx_id_t context_handle,
     270                 :            :                  const gss_buffer_t input_message_buffer,
     271                 :            :                  gss_buffer_t output_message_buffer,
     272                 :            :                  int *conf_state, gss_qop_t * qop_state)
     273                 :            : {
     274                 :          3 :   _gss_krb5_ctx_t k5 = context_handle->krb5;
     275                 :            :   gss_buffer_desc tok;
     276                 :            :   char *data;
     277                 :            :   OM_uint32 sgn_alg, seal_alg;
     278                 :            :   size_t tmplen;
     279                 :            :   int rc;
     280                 :            : 
     281                 :          3 :   rc = gss_decapsulate_token (input_message_buffer, GSS_KRB5, &tok);
     282         [ -  + ]:          3 :   if (rc != GSS_S_COMPLETE)
     283                 :          0 :     return GSS_S_BAD_MIC;
     284                 :            : 
     285         [ -  + ]:          3 :   if (tok.length < 8)
     286                 :          0 :     return GSS_S_BAD_MIC;
     287                 :            : 
     288         [ -  + ]:          3 :   if (memcmp (tok.value, TOK_WRAP, TOK_LEN) != 0)
     289                 :          0 :     return GSS_S_BAD_MIC;
     290                 :            : 
     291                 :          3 :   data = tok.value;
     292                 :            : 
     293                 :          3 :   sgn_alg = data[2] & 0xFF;
     294                 :          3 :   sgn_alg |= data[3] << 8 & 0xFF00;
     295                 :            : 
     296                 :          3 :   seal_alg = data[4] & 0xFF;
     297                 :          3 :   seal_alg |= data[5] << 8 & 0xFF00;
     298                 :            : 
     299         [ +  - ]:          3 :   if (conf_state != NULL)
     300                 :          3 :     *conf_state = seal_alg == 0xFFFF;
     301                 :            : 
     302         [ -  + ]:          3 :   if (memcmp (data + 6, "\xFF\xFF", 2) != 0)
     303                 :          0 :     return GSS_S_BAD_MIC;
     304                 :            : 
     305      [ +  -  - ]:          3 :   switch (sgn_alg)
     306                 :            :     {
     307                 :            :       /* XXX implement other checksums */
     308                 :            : 
     309                 :            :     case 0:                     /* DES-MD5 */
     310                 :            :       {
     311                 :            :         size_t padlen;
     312                 :            :         char *pt;
     313                 :            :         char header[8];
     314                 :            :         char encseqno[8];
     315                 :            :         char seqno[8];
     316                 :            :         char cksum[8];
     317                 :            :         char confounder[8];
     318                 :            :         char *tmp;
     319                 :            :         uint32_t seqnr;
     320                 :            :         size_t outlen, i;
     321                 :            : 
     322                 :            :         /* Typical data:
     323                 :            :            ;; 02 01 00 00 ff ff ff ff  0c 22 1f 79 59 3d 00 cb
     324                 :            :            ;; d5 78 2f fb 50 d2 b8 59  fb b4 e0 9b d0 a2 fa dc
     325                 :            :            ;; 01 00 20 00 04 04 04 04
     326                 :            :            Translates into:
     327                 :            :            ;;   HEADER                 ENCRYPTED SEQ.NUMBER
     328                 :            :            ;;   DES-MAC-MD5 CKSUM      CONFOUNDER
     329                 :            :            ;;   PADDED DATA
     330                 :            :          */
     331                 :            : 
     332         [ -  + ]:          3 :         if (tok.length < 5 * 8)
     333                 :          0 :           return GSS_S_BAD_MIC;
     334                 :            : 
     335                 :          3 :         memcpy (header, data, 8);
     336                 :          3 :         memcpy (encseqno, data + 8, 8);
     337                 :          3 :         memcpy (cksum, data + 16, 8);
     338                 :          3 :         memcpy (confounder, data + 24, 8);
     339                 :          3 :         pt = data + 32;
     340                 :            : 
     341                 :            :         /* XXX decrypt data iff confidential option chosen */
     342                 :            : 
     343                 :          3 :         rc = shishi_decrypt_iv_etype (k5->sh,
     344                 :            :                                       k5->key,
     345                 :            :                                       0, SHISHI_DES_CBC_NONE,
     346                 :            :                                       cksum, 8, encseqno, 8, &tmp, &outlen);
     347         [ -  + ]:          3 :         if (rc != SHISHI_OK)
     348                 :          0 :           return GSS_S_FAILURE;
     349         [ -  + ]:          3 :         if (outlen != 8)
     350                 :          0 :           return GSS_S_BAD_MIC;
     351                 :          3 :         memcpy (seqno, tmp, 8);
     352                 :          3 :         free (tmp);
     353                 :            : 
     354 [ +  - ][ -  + ]:          3 :         if (memcmp (seqno + 4, k5->acceptor ? "\x00\x00\x00\x00" :
     355                 :            :                     "\xFF\xFF\xFF\xFF", 4) != 0)
     356                 :          0 :           return GSS_S_BAD_MIC;
     357                 :            : 
     358                 :          3 :         seqnr = C2I (seqno);
     359 [ +  - ][ -  + ]:          3 :         if (seqnr != (k5->acceptor ? k5->initseqnr : k5->acceptseqnr))
     360                 :          0 :           return GSS_S_BAD_MIC;
     361                 :            : 
     362         [ +  - ]:          3 :         if (k5->acceptor)
     363                 :          3 :           k5->initseqnr++;
     364                 :            :         else
     365                 :          0 :           k5->acceptseqnr++;
     366                 :            : 
     367                 :            :         /* Check pad */
     368                 :          3 :         padlen = data[tok.length - 1];
     369         [ -  + ]:          3 :         if (padlen > 8)
     370                 :          0 :           return GSS_S_BAD_MIC;
     371         [ +  + ]:         15 :         for (i = 1; i <= padlen; i++)
     372         [ -  + ]:         12 :           if (data[tok.length - i] != (int) padlen)
     373                 :          0 :             return GSS_S_BAD_MIC;
     374                 :            : 
     375                 :            :         /* Write header and confounder next to data */
     376                 :          3 :         memcpy (data + 16, header, 8);
     377                 :          3 :         memcpy (data + 24, confounder, 8);
     378                 :            : 
     379                 :            :         /* Checksum header + confounder + data + pad */
     380                 :          3 :         rc = shishi_checksum (k5->sh,
     381                 :            :                               k5->key,
     382                 :            :                               0, SHISHI_RSA_MD5_DES_GSS,
     383                 :            :                               data + 16, tok.length - 16, &tmp, &tmplen);
     384   [ +  -  -  + ]:          3 :         if (rc != SHISHI_OK || tmplen != 8)
     385                 :          0 :           return GSS_S_FAILURE;
     386                 :            : 
     387                 :          3 :         memcpy (data + 8, tmp, tmplen);
     388                 :            : 
     389                 :            :         /* Compare checksum */
     390 [ +  - ][ -  + ]:          3 :         if (tmplen != 8 || memcmp (cksum, data + 8, 8) != 0)
     391                 :          0 :           return GSS_S_BAD_MIC;
     392                 :            : 
     393                 :            :         /* Copy output data */
     394                 :          3 :         output_message_buffer->length = tok.length - 8 - 8 - 8 - 8 - padlen;
     395                 :          3 :         output_message_buffer->value = malloc (output_message_buffer->length);
     396         [ -  + ]:          3 :         if (!output_message_buffer->value)
     397                 :            :           {
     398         [ #  # ]:          0 :             if (minor_status)
     399                 :          0 :               *minor_status = ENOMEM;
     400                 :          0 :             return GSS_S_FAILURE;
     401                 :            :           }
     402                 :            : 
     403                 :          3 :         memcpy (output_message_buffer->value, pt,
     404                 :            :                 tok.length - 4 * 8 - padlen);
     405                 :            :       }
     406                 :          3 :       break;
     407                 :            : 
     408                 :            :     case 4:                     /* 3DES */
     409                 :            :       {
     410                 :            :         size_t padlen;
     411                 :            :         char *p;
     412                 :            :         char *t;
     413                 :            :         char cksum[20];
     414                 :            :         size_t outlen, i;
     415                 :            :         uint32_t seqnr;
     416                 :            : 
     417         [ #  # ]:          0 :         if (tok.length < 8 + 8 + 20 + 8 + 8)
     418                 :          0 :           return GSS_S_BAD_MIC;
     419                 :            : 
     420                 :          0 :         memcpy (cksum, data + 8 + 8, 20);
     421                 :            : 
     422                 :            :         /* XXX decrypt data iff confidential option chosen */
     423                 :            : 
     424                 :          0 :         p = data + 8;
     425                 :          0 :         rc = shishi_decrypt_iv_etype (k5->sh,
     426                 :            :                                       k5->key,
     427                 :            :                                       0, SHISHI_DES3_CBC_NONE,
     428                 :            :                                       cksum, 8, p, 8, &t, &outlen);
     429   [ #  #  #  # ]:          0 :         if (rc != SHISHI_OK || outlen != 8)
     430                 :          0 :           return GSS_S_FAILURE;
     431                 :            : 
     432                 :          0 :         memcpy (p, t, 8);
     433                 :          0 :         free (t);
     434                 :            : 
     435 [ #  # ][ #  # ]:          0 :         if (memcmp (p + 4, k5->acceptor ? "\x00\x00\x00\x00" :
     436                 :            :                     "\xFF\xFF\xFF\xFF", 4) != 0)
     437                 :          0 :           return GSS_S_BAD_MIC;
     438                 :          0 :         seqnr = C2I (p);
     439 [ #  # ][ #  # ]:          0 :         if (seqnr != (k5->acceptor ? k5->initseqnr : k5->acceptseqnr))
     440                 :          0 :           return GSS_S_BAD_MIC;
     441                 :            : 
     442         [ #  # ]:          0 :         if (k5->acceptor)
     443                 :          0 :           k5->initseqnr++;
     444                 :            :         else
     445                 :          0 :           k5->acceptseqnr++;
     446                 :            : 
     447                 :            :         /* Check pad */
     448                 :          0 :         padlen = data[tok.length - 1];
     449         [ #  # ]:          0 :         if (padlen > 8)
     450                 :          0 :           return GSS_S_BAD_MIC;
     451         [ #  # ]:          0 :         for (i = 1; i <= padlen; i++)
     452         [ #  # ]:          0 :           if (data[tok.length - i] != (int) padlen)
     453                 :          0 :             return GSS_S_BAD_MIC;
     454                 :            : 
     455                 :            :         /* Write header next to confounder */
     456                 :          0 :         memcpy (data + 8 + 20, data, 8);
     457                 :            : 
     458                 :            :         /* Checksum header + confounder + data + pad */
     459                 :          0 :         rc = shishi_checksum (k5->sh,
     460                 :            :                               k5->key,
     461                 :            :                               SHISHI_KEYUSAGE_GSS_R2,
     462                 :            :                               SHISHI_HMAC_SHA1_DES3_KD, data + 20 + 8,
     463                 :            :                               tok.length - 20 - 8, &t, &tmplen);
     464   [ #  #  #  # ]:          0 :         if (rc != SHISHI_OK || tmplen != 20)
     465                 :          0 :           return GSS_S_FAILURE;
     466                 :            : 
     467                 :          0 :         memcpy (data + 8 + 8, t, tmplen);
     468                 :          0 :         free (t);
     469                 :            : 
     470                 :            :         /* Compare checksum */
     471 [ #  # ][ #  # ]:          0 :         if (tmplen != 20 || memcmp (cksum, data + 8 + 8, 20) != 0)
     472                 :          0 :           return GSS_S_BAD_MIC;
     473                 :            : 
     474                 :            :         /* Copy output data */
     475                 :          0 :         output_message_buffer->length = tok.length - 8 - 20 - 8 - 8 - padlen;
     476                 :          0 :         output_message_buffer->value = malloc (output_message_buffer->length);
     477         [ #  # ]:          0 :         if (!output_message_buffer->value)
     478                 :            :           {
     479         [ #  # ]:          0 :             if (minor_status)
     480                 :          0 :               *minor_status = ENOMEM;
     481                 :          0 :             return GSS_S_FAILURE;
     482                 :            :           }
     483                 :          0 :         memcpy (output_message_buffer->value, data + 20 + 8 + 8 + 8,
     484                 :            :                 tok.length - 20 - 8 - 8 - 8 - padlen);
     485                 :            :       }
     486                 :          0 :       break;
     487                 :            : 
     488                 :            :     default:
     489                 :          0 :       return GSS_S_FAILURE;
     490                 :            :     }
     491                 :            : 
     492                 :          3 :   return GSS_S_COMPLETE;
     493                 :            : }

Generated by: LCOV version 1.8