LCOV - code coverage report
Current view: top level - lib/digest-md5 - test-parser.c (source / functions) Hit Total Coverage
Test: GNU SASL Lines: 86 106 81.1 %
Date: 2010-09-27 Functions: 1 1 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 24 48 50.0 %

           Branch data     Line data    Source code
       1                 :            : /* test-parser.c --- Self tests of DIGEST-MD5 parser & printer.
       2                 :            :  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009  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                 :            : #include <stdio.h>
      24                 :            : #include <stdlib.h>
      25                 :            : #include <string.h>
      26                 :            : 
      27                 :            : #include "parser.h"
      28                 :            : #include "printer.h"
      29                 :            : #include "digesthmac.h"
      30                 :            : 
      31                 :            : #include "gc.h"
      32                 :            : 
      33                 :            : int
      34                 :          1 : main (int argc, char *argv[])
      35                 :            : {
      36                 :            :   digest_md5_challenge c;
      37                 :            :   digest_md5_response r;
      38                 :            :   digest_md5_finish f;
      39                 :            :   char buf32[33];
      40                 :            :   char buf16[16];
      41                 :            :   int rc;
      42                 :            :   char *tmp;
      43                 :            : 
      44                 :            :   {
      45                 :          1 :     const char *token = "nonce=4711, foo=bar, algorithm=md5-sess";
      46                 :            : 
      47                 :          1 :     printf ("challenge `%s': ", token);
      48                 :          1 :     rc = digest_md5_parse_challenge (token, 0, &c);
      49         [ -  + ]:          1 :     if (rc != 0)
      50                 :          0 :       abort ();
      51         [ +  - ]:          1 :     printf ("nonce `%s': %s", c.nonce,
      52                 :          1 :             strcmp ("4711", c.nonce) == 0 ? "PASS" : "FAILURE");
      53                 :          1 :     printf ("\n");
      54                 :          1 :     tmp = digest_md5_print_challenge (&c);
      55         [ -  + ]:          1 :     if (!tmp)
      56                 :          0 :       abort ();
      57                 :          1 :     printf ("printed `%s' PASS\n", tmp);
      58                 :          1 :     free (tmp);
      59                 :            :   }
      60                 :            : 
      61                 :            :   {
      62                 :          1 :     const char *token = "qop=\"auth, auth-conf\", nonce=42, algorithm=md5-sess";
      63                 :            : 
      64                 :          1 :     printf ("challenge `%s': ", token);
      65                 :          1 :     rc = digest_md5_parse_challenge (token, 0, &c);
      66         [ -  + ]:          1 :     if (rc == 0)
      67                 :          0 :       abort ();
      68                 :          1 :     printf ("PASS\n");
      69                 :            :   }
      70                 :            : 
      71                 :            :   {
      72                 :          1 :     const char *token = "cipher=\"des\", nonce=42, algorithm=md5-sess";
      73                 :            : 
      74                 :          1 :     printf ("challenge `%s': ", token);
      75                 :          1 :     rc = digest_md5_parse_challenge (token, 0, &c);
      76         [ -  + ]:          1 :     if (rc == 0)
      77                 :          0 :       abort ();
      78                 :          1 :     printf ("PASS\n");
      79                 :            :   }
      80                 :            : 
      81                 :            :   {
      82                 :            :     const char *token = "qop=\"auth, auth-conf\", nonce=42, "
      83                 :          1 :       "algorithm=md5-sess, cipher=\"des\"";
      84                 :            : 
      85                 :          1 :     printf ("challenge `%s': ", token);
      86                 :          1 :     rc = digest_md5_parse_challenge (token, 0, &c);
      87         [ -  + ]:          1 :     if (rc != 0)
      88                 :          0 :       abort ();
      89 [ +  - ][ +  - ]:          1 :     printf ("qop %02x ciphers %02x: %s\n", c.qops, c.ciphers,
      90                 :          2 :             (c.qops == 5 && c.ciphers == 1) ? "PASS" : "FAILURE");
      91                 :          1 :     tmp = digest_md5_print_challenge (&c);
      92         [ -  + ]:          1 :     if (!tmp)
      93                 :          0 :       abort ();
      94                 :          1 :     printf ("printed `%s' PASS\n", tmp);
      95                 :          1 :     free (tmp);
      96                 :            :   }
      97                 :            : 
      98                 :            :   {
      99                 :          1 :     const char *token = "bar=foo, foo=bar";
     100                 :            : 
     101                 :          1 :     printf ("challenge `%s': ", token);
     102                 :          1 :     rc = digest_md5_parse_challenge (token, 0, &c);
     103         [ -  + ]:          1 :     if (rc == 0)
     104                 :          0 :       abort ();
     105                 :          1 :     printf ("PASS\n");
     106                 :            :   }
     107                 :            : 
     108                 :            :   {
     109                 :          1 :     const char *token = "realm=foo, realm=bar, nonce=42, algorithm=md5-sess";
     110                 :            : 
     111                 :          1 :     printf ("challenge `%s': ", token);
     112                 :          1 :     rc = digest_md5_parse_challenge (token, 0, &c);
     113         [ -  + ]:          1 :     if (rc != 0)
     114                 :          0 :       abort ();
     115         [ -  + ]:          1 :     if (c.nrealms != 2)
     116                 :          0 :       abort ();
     117                 :          1 :     printf ("realms `%s', `%s': PASS\n", c.realms[0], c.realms[1]);
     118                 :          1 :     tmp = digest_md5_print_challenge (&c);
     119         [ -  + ]:          1 :     if (!tmp)
     120                 :          0 :       abort ();
     121                 :          1 :     printf ("printed `%s' PASS\n", tmp);
     122                 :          1 :     free (tmp);
     123                 :            :   }
     124                 :            : 
     125                 :            :   /* Response */
     126                 :            : 
     127                 :            :   {
     128                 :          1 :     const char *token = "bar=foo, foo=bar";
     129                 :            : 
     130                 :          1 :     printf ("response `%s': ", token);
     131                 :          1 :     rc = digest_md5_parse_response (token, 0, &r);
     132         [ -  + ]:          1 :     if (rc == 0)
     133                 :          0 :       abort ();
     134                 :          1 :     printf ("PASS\n");
     135                 :            :   }
     136                 :            : 
     137                 :            :   {
     138                 :            :     const char *token = "username=jas, nonce=42, cnonce=4711, nc=00000001, "
     139                 :          1 :       "digest-uri=foo, response=01234567890123456789012345678901";
     140                 :            : 
     141                 :          1 :     printf ("response `%s': ", token);
     142                 :          1 :     rc = digest_md5_parse_response (token, 0, &r);
     143         [ -  + ]:          1 :     if (rc != 0)
     144                 :          0 :       abort ();
     145                 :          1 :     printf ("username `%s', nonce `%s', cnonce `%s',"
     146                 :            :             " nc %08lx, digest-uri `%s', response `%s': PASS\n",
     147                 :            :             r.username, r.nonce, r.cnonce, r.nc, r.digesturi, r.response);
     148                 :          1 :     tmp = digest_md5_print_response (&r);
     149         [ -  + ]:          1 :     if (!tmp)
     150                 :          0 :       abort ();
     151                 :          1 :     printf ("printed `%s' PASS\n", tmp);
     152                 :          1 :     free (tmp);
     153                 :            :   }
     154                 :            : 
     155                 :            :   /* Auth-response, finish. */
     156                 :            : 
     157                 :            :   {
     158                 :          1 :     const char *token = "rspauth=\"6a204da26b9888ee40bb3052ff056a67\"";
     159                 :            : 
     160                 :          1 :     printf ("finish `%s': ", token);
     161                 :          1 :     rc = digest_md5_parse_finish (token, 0, &f);
     162         [ -  + ]:          1 :     if (rc != 0)
     163                 :          0 :       abort ();
     164         [ +  - ]:          1 :     printf ("`%s'? %s\n", f.rspauth,
     165                 :          1 :             strcmp ("6a204da26b9888ee40bb3052ff056a67", f.rspauth) == 0
     166                 :            :             ? "ok" : "FAILURE");
     167                 :            :   }
     168                 :            : 
     169                 :            :   {
     170                 :          1 :     const char *token = "bar=foo, foo=bar";
     171                 :            : 
     172                 :          1 :     printf ("finish `%s': ", token);
     173                 :          1 :     rc = digest_md5_parse_finish (token, 0, &f);
     174         [ -  + ]:          1 :     if (rc == 0)
     175                 :          0 :       abort ();
     176                 :          1 :     printf ("invalid? PASS\n");
     177                 :            :   }
     178                 :            : 
     179                 :          1 :   rc = gc_init ();
     180         [ -  + ]:          1 :   if (rc != 0)
     181                 :          0 :     abort ();
     182                 :            : 
     183                 :          1 :   memset (buf16, 'Q', 16);
     184                 :            : 
     185                 :          1 :   rc = digest_md5_hmac (buf32, buf16, "nonce", 1, "cnonce",
     186                 :            :                         DIGEST_MD5_QOP_AUTH, "authzid", "digesturi",
     187                 :            :                         1, 0, NULL, NULL, NULL, NULL);
     188         [ -  + ]:          1 :   if (rc != 0)
     189                 :          0 :     abort ();
     190                 :          1 :   buf32[32] = '\0';
     191         [ -  + ]:          1 :   if (strcmp (buf32, "6a204da26b9888ee40bb3052ff056a67") != 0)
     192                 :          0 :     abort ();
     193                 :          1 :   printf ("digest: `%s': PASS\n", buf32);
     194                 :            : 
     195                 :          1 :   rc = digest_md5_hmac (buf32, buf16, "nonce", 1, "cnonce",
     196                 :            :                         DIGEST_MD5_QOP_AUTH, "authzid", "digesturi", 0, 0,
     197                 :            :                         NULL, NULL, NULL, NULL);
     198         [ -  + ]:          1 :   if (rc != 0)
     199                 :          0 :     abort ();
     200                 :          1 :   buf32[32] = '\0';
     201         [ -  + ]:          1 :   if (strcmp (buf32, "6c1f58bfa46e9c225b93745c84204efd") != 0)
     202                 :          0 :     abort ();
     203                 :          1 :   printf ("digest: `%s': PASS\n", buf32);
     204                 :            : 
     205                 :          1 :   return 0;
     206                 :            : }

Generated by: LCOV version 1.8