LCOV - code coverage report
Current view: top level - zxid - zxlogview.c (source / functions) Hit Total Coverage
Test: ZXID Code Coverage Lines: 96 192 50.0 %
Date: 2010-12-19 Functions: 3 4 75.0 %
Branches: 45 125 36.0 %

           Branch data     Line data    Source code
       1                 :            : /* zxlogview.c  -  Encrypted and signed log decoder
       2                 :            :  * Copyright (c) 2010 Sampo Kellomaki (sampo@iki.fi), All Rights Reserved.
       3                 :            :  * Copyright (c) 2006-2009 Symlabs (symlabs@symlabs.com), All Rights Reserved.
       4                 :            :  * Author: Sampo Kellomaki (sampo@iki.fi)
       5                 :            :  * This is confidential unpublished proprietary source code of the author.
       6                 :            :  * NO WARRANTY, not even implied warranties. Contains trade secrets.
       7                 :            :  * Distribution prohibited unless authorized in writing.
       8                 :            :  * Licensed under Apache License 2.0, see file COPYING.
       9                 :            :  * $Id: zxlogview.c,v 1.15 2009-11-24 23:53:40 sampo Exp $
      10                 :            :  *
      11                 :            :  * 19.11.2006, started --Sampo
      12                 :            :  * 29.8.2009, added hmac chaining field --Sampo
      13                 :            :  *
      14                 :            :  * TODO Ideas
      15                 :            :  *
      16                 :            :  * 1. DONE: Decrypt log lines and validate signatures
      17                 :            :  * 2. Add some form of summary report gathered from the processed log lines.
      18                 :            :  *    - sig failures
      19                 :            :  *    - other errors
      20                 :            :  *    - activity by IdP
      21                 :            :  *    - activity by user (name ID)
      22                 :            :  *    - activity in timeline
      23                 :            :  *    - activity by operation
      24                 :            :  * 3. Using /var/zxid/cot dereference the sha1 names to entity IDs
      25                 :            :  * 4. Using /var/zxid/log/rely (and issue) chase the referenced
      26                 :            :  *    assertions and validate them (sig, conditions, etc.) and
      27                 :            :  *    extract statistics from them.
      28                 :            :  * 5. Simple decryptor and signature verificator for encrypted
      29                 :            :  *    files (e.g. rely assertions) (gpg or other standard compatible?)
      30                 :            :  * 6. Regression test mode
      31                 :            :  */
      32                 :            : 
      33                 :            : #include <string.h>
      34                 :            : #include <stdio.h>
      35                 :            : #include <stdlib.h>
      36                 :            : #include <errno.h>
      37                 :            : 
      38                 :            : #ifdef USE_OPENSSL
      39                 :            : #include <openssl/x509.h>
      40                 :            : #include <openssl/rsa.h>
      41                 :            : #include <openssl/aes.h>
      42                 :            : #endif
      43                 :            : 
      44                 :            : #include "errmac.h"
      45                 :            : #include "zx.h"
      46                 :            : #include "zxid.h"
      47                 :            : #include "zxidutil.h"
      48                 :            : #include "c/zxidvers.h"
      49                 :            : 
      50                 :            : char* help =
      51                 :            : "zxlogview  -  Decrypt logs and validate log signatures - R" ZXID_REL "\n\
      52                 :            : SAML 2.0 is a standard for federated identity and Single Sign-On.\n\
      53                 :            : Copyright (c) 2010 Sampo Kellomaki (sampo@iki.fi), All Rights Reserved.\n\
      54                 :            : Copyright (c) 2006-2009 Symlabs (symlabs@symlabs.com), All Rights Reserved.\n\
      55                 :            : Author: Sampo Kellomaki (sampo@iki.fi)\n\
      56                 :            : NO WARRANTY, not even implied warranties. Licensed under Apache License v2.0\n\
      57                 :            : See http://www.apache.org/licenses/LICENSE-2.0\n\
      58                 :            : Send well researched bug reports to the author. Home: zxid.org\n\
      59                 :            : \n\
      60                 :            : Usage: zxlogview [options] logsign-nopw-cert.pem logenc-nopw-cert.pem <loglines\n\
      61                 :            :   -t        Test mode. The certificates are interpretted from enc & sign perspective.\n\
      62                 :            :   -v        Verbose messages.\n\
      63                 :            :   -q        Be extra quiet.\n\
      64                 :            :   -d        Turn on debugging.\n\
      65                 :            :   -license  Show licensing and NO WARRANTY details.\n\
      66                 :            :   -h        This help message\n\
      67                 :            :   --        End of options\n";
      68                 :            : 
      69                 :            : #define DIE(reason) MB fprintf(stderr, "%s\n", reason); exit(2); ME
      70                 :            : 
      71                 :            : int verbose = 1;
      72                 :            : extern int zx_debug;
      73                 :            : int leak_free = 0;
      74                 :            : 
      75                 :            : X509* log_verify_cert;
      76                 :            : EVP_PKEY* log_decrypt_pkey;
      77                 :            : char  log_symkey[20];
      78                 :            : char  buf[4096];
      79                 :            : 
      80                 :            : static void test_mode(int* argc, char*** argv, char*** env);
      81                 :            : 
      82                 :            : /* Called by:  main x8, zxcall_main, zxcot_main, zxdecode_main */
      83                 :            : static void opt(int* argc, char*** argv, char*** env)
      84                 :          6 : {
      85                 :            :   int gotall;
      86         [ +  - ]:          6 :   if (*argc <= 1) goto argerr;
      87                 :            :   
      88                 :            :   while (1) {
      89                 :         13 :     ++(*argv); --(*argc);
      90                 :            :     
      91   [ +  +  +  + ]:         13 :     if (!(*argc) || ((*argv)[0][0] != '-')) break;  /* start of non option arguments */
      92                 :            :     
      93   [ +  +  +  +  :         11 :     switch ((*argv)[0][1]) {
             +  +  +  + ]
      94         [ +  - ]:          1 :     case '-': if ((*argv)[0][2]) break;
      95                 :          1 :       ++(*argv); --(*argc);
      96                 :            :       DD("End of options by --");
      97                 :          1 :       return;  /* -- ends the options */
      98                 :            : 
      99                 :            :     case 'd':
     100      [ +  +  - ]:          2 :       switch ((*argv)[0][2]) {
     101                 :            :       case '\0':
     102                 :          1 :         ++zx_debug;
     103                 :          1 :         continue;
     104         [ +  - ]:          1 :       case 'i':  if ((*argv)[0][3]) break;
     105                 :          1 :         ++(*argv); --(*argc);
     106         [ +  - ]:          1 :         if (!(*argc)) break;
     107                 :          1 :         strcpy(zx_instance, (*argv)[0]);
     108                 :          1 :         continue;
     109                 :            :       }
     110                 :          0 :       break;
     111                 :            : 
     112                 :            :     case 'v':
     113         [ +  - ]:          2 :       switch ((*argv)[0][2]) {
     114                 :            :       case '\0':
     115                 :          2 :         ++verbose;
     116                 :          2 :         continue;
     117                 :            :       }
     118                 :          0 :       break;
     119                 :            : 
     120                 :            :     case 'q':
     121         [ +  - ]:          1 :       switch ((*argv)[0][2]) {
     122                 :            :       case '\0':
     123                 :          1 :         verbose = 0;
     124                 :          1 :         continue;
     125                 :            :       }
     126                 :          0 :       break;
     127                 :            :       
     128                 :            :     case 'r':
     129      [ +  +  - ]:          2 :       switch ((*argv)[0][2]) {
     130                 :            :       case 'f':
     131                 :            :         /*AFR_TS(LEAK, 0, "memory leaks enabled");*/
     132                 :            : #if 1
     133                 :          1 :         ERR("*** WARNING: You have turned memory frees to memory leaks. We will (eventually) run out of memory. Using -rf is not recommended. %d\n", 0);
     134                 :            : #endif
     135                 :          1 :         ++leak_free;
     136                 :          1 :         continue;
     137                 :            : #if 0
     138                 :            :       case 'e':
     139                 :            :         if ((*argv)[0][3]) break;
     140                 :            :         ++(*argv); --(*argc);
     141                 :            :         if ((*argc) < 4) break;
     142                 :            :         sscanf((*argv)[0], "%i", &abort_funcno);
     143                 :            :         ++(*argv); --(*argc);
     144                 :            :         sscanf((*argv)[0], "%i", &abort_line);
     145                 :            :         ++(*argv); --(*argc);
     146                 :            :         sscanf((*argv)[0], "%i", &abort_error_code);
     147                 :            :         ++(*argv); --(*argc);
     148                 :            :         sscanf((*argv)[0], "%i", &abort_iter);
     149                 :            :         fprintf(stderr, "Will force core upon %x:%x err=%d iter=%d\n",
     150                 :            :                 abort_funcno, abort_line, abort_error_code, abort_iter);
     151                 :            :         continue;
     152                 :            : #endif
     153                 :            :       case 'a':
     154         [ +  - ]:          1 :         if ((*argv)[0][3] == 0) {
     155                 :            :           /*AFR_TS(ASSERT_NONFATAL, 0, "assert nonfatal enabled");*/
     156                 :            : #if 1
     157                 :          1 :           ERR("*** WARNING: YOU HAVE TURNED ASSERTS OFF USING -ra FLAG. THIS MEANS THAT YOU WILL NOT BE ABLE TO OBTAIN ANY SUPPORT. IF PROGRAM NOW TRIES TO ASSERT IT MAY MYSTERIOUSLY AND UNPREDICTABLY CRASH INSTEAD, AND NOBODY WILL BE ABLE TO FIGURE OUT WHAT WENT WRONG OR HOW MUCH DAMAGE MAY BE DONE. USING -ra IS NOT RECOMMENDED. %d\n", assert_nonfatal);
     158                 :            : #endif
     159                 :          1 :           ++assert_nonfatal;
     160                 :          1 :           continue;
     161                 :            :         }
     162                 :            :         break;
     163                 :            :       }
     164                 :          0 :       break;
     165                 :            : 
     166                 :            :     case 'l':
     167         [ +  - ]:          1 :       switch ((*argv)[0][2]) {
     168                 :            :       case 'i':
     169         [ +  - ]:          1 :         if (!strcmp((*argv)[0],"-license")) {
     170                 :            :           extern char* license;
     171                 :          1 :           fprintf(stderr, license);
     172                 :          1 :           exit(0);
     173                 :            :         }
     174                 :            :         break;
     175                 :            :       }
     176                 :          0 :       break;
     177                 :            :       
     178                 :          1 :     case 't': test_mode(argc, argv, env);
     179                 :            :     } 
     180                 :            :     /* fall thru means unrecognized flag */
     181         [ +  - ]:          1 :     if (*argc)
     182                 :          1 :       fprintf(stderr, "Unrecognized flag `%s'\n", (*argv)[0]);
     183                 :          1 :   argerr:
     184         [ +  - ]:          1 :     if (verbose>1) {
     185                 :          1 :       printf(help);
     186                 :          1 :       exit(0);
     187                 :            :     }
     188                 :          0 :     fprintf(stderr, help);
     189                 :          0 :     exit(3);
     190                 :          7 :   }
     191                 :            : 
     192         [ +  + ]:          2 :   if (*argc) {  /* Signature verification certificate (logsign-nopw-cert.pem) */
     193         [ +  - ]:          1 :     if ((*argv)[0][0]) {
     194                 :          1 :       read_all(sizeof(buf), buf, "logview opt cert", 1, "%s", (*argv)[0]);
     195                 :          1 :       log_verify_cert = zxid_extract_cert(buf, (*argv)[0]);
     196                 :            :     }
     197                 :          1 :     ++(*argv); --(*argc);
     198                 :            :   }
     199                 :            : 
     200         [ +  + ]:          2 :   if (*argc) {  /* Log decryption key (logenc-nopw-cert.pem) */
     201         [ +  - ]:          1 :     if ((*argv)[0][0]) {
     202                 :          1 :       gotall = read_all(sizeof(buf), buf, "logview opt key", 1, "%s", (*argv)[0]);
     203                 :          1 :       SHA1((unsigned char*)buf, gotall, (unsigned char*)log_symkey);
     204                 :          1 :       log_decrypt_pkey = zxid_extract_private_key(buf, (*argv)[0]);
     205                 :            :     }
     206                 :          1 :     ++(*argv); --(*argc);
     207                 :            :   }
     208                 :            : }
     209                 :            : 
     210                 :            : /* Called by:  opt */
     211                 :            : static void test_mode(int* argc, char*** argv, char*** env)
     212                 :          1 : {
     213                 :            :   int gotall;
     214                 :          1 :   zxid_conf* cf = zxid_new_conf(0);
     215                 :            : 
     216                 :          1 :   ++(*argv); --(*argc);
     217         [ +  - ]:          1 :   if (*argc) {  /* Signature verification certificate (logsign-nopw-cert.pem) */
     218         [ +  - ]:          1 :     if ((*argv)[0][0]) {
     219                 :          1 :       read_all(sizeof(buf), buf, "logview test_mode private key", 1, "%s", (*argv)[0]);
     220                 :          1 :       cf->log_sign_pkey = zxid_extract_private_key(buf, (*argv)[0]);
     221                 :            :     }
     222                 :          1 :     ++(*argv); --(*argc);
     223                 :            :   }
     224                 :            :   
     225         [ +  - ]:          1 :   if (*argc) {  /* Log encryption key (logenc-nopw-cert.pem) */
     226         [ +  - ]:          1 :     if ((*argv)[0][0]) {
     227                 :          1 :       gotall = read_all(sizeof(buf), buf, "logview test_mode key", 1, "%s", (*argv)[0]);
     228                 :          1 :       SHA1((unsigned char*)buf, gotall, (unsigned char*)cf->log_symkey);
     229                 :          1 :       cf->log_enc_cert = zxid_extract_cert(buf, (*argv)[0]);
     230                 :            :     }
     231                 :          1 :     ++(*argv); --(*argc);
     232                 :            :   }
     233                 :            : 
     234                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x01, -2, "test1 Plain none\n");
     235                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x03, -2, "test2 Plain SHA1\n");
     236                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x05, -2, "test3 Plain RSA sig\n");
     237                 :            : 
     238                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x11, -2, "test4 zip none\n");
     239                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x13, -2, "test5 zip SHA1\n");
     240                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x15, -2, "test6 zip RSA sig\n");
     241                 :            :   
     242                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x21, -2, "test7 RSA-AES none\n");
     243                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x23, -2, "test8 RSA-AES SHA1\n");
     244                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x25, -2, "test9 RSA-AES RSA sig\n");
     245                 :            : 
     246                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x41, -2, "test10 AES none\n");
     247                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x43, -2, "test11 AES SHA1\n");
     248                 :          1 :   zxlog_write_line(cf, "zxlogview-test.out", 0x45, -2, "test12 AES RSA sig\n");
     249                 :            : 
     250                 :          1 :   exit(0);
     251                 :            : }
     252                 :            : 
     253                 :            : /* Called by:  main x3 */
     254                 :            : static void zxlog_zsig_verify_print(zxid_conf* cf, int len, char* buf, char* se, char* p)
     255                 :          0 : {
     256                 :            :   char sha1[20];
     257                 :            :   char* sig;
     258                 :          0 :   int verdict, siglen = (unsigned char)p[0] << 8 | (unsigned char)p[1];
     259   [ #  #  #  # ]:          0 :   D("siglen(%d)", siglen);
     260                 :          0 :   sig = p+2;
     261                 :          0 :   p += 2+siglen;
     262                 :            :   
     263   [ #  #  #  #  :          0 :   switch (se[0]) {
                      # ]
     264                 :            :   case 'P':
     265         [ #  # ]:          0 :     if (siglen) {
     266                 :          0 :       ERR("No sig, siglen should be zero. Found %d", siglen);
     267                 :          0 :       break;
     268                 :            :     }
     269                 :          0 :     break;
     270                 :            :   case 'R':
     271         [ #  # ]:          0 :     if (!siglen) {
     272                 :          0 :       ERR("RSA sig claimed by no sig found. %d", siglen);
     273                 :          0 :       break;
     274                 :            :     }
     275                 :          0 :     verdict = zxsig_verify_data(len-(p-buf), p, siglen, sig, log_verify_cert, "log vfy");
     276         [ #  # ]:          0 :     if (verdict) {
     277                 :          0 :       printf("RSA signature FAIL. Log file may have been tampered - or bad certificate.\n");
     278                 :            :     } else {
     279                 :          0 :       printf("RSA signature OK\n");
     280                 :            :     }
     281                 :          0 :     break;
     282                 :          0 :   case 'D':  ERR("Unimplemented sign %c", se[1]); break;
     283                 :            :   case 'S':
     284         [ #  # ]:          0 :     if (siglen != 20) {
     285                 :          0 :       ERR("Wrong sha1 length in input %d", siglen);
     286                 :          0 :       break;
     287                 :            :     }
     288                 :          0 :     SHA1((unsigned char*)p, len-(p-buf), (unsigned char*)sha1);
     289         [ #  # ]:          0 :     if (memcmp(sha1, buf+2, 20)) {
     290                 :          0 :       printf("SHA1 FAIL\n");
     291                 :            :     } else {
     292                 :          0 :       printf("SHA1 OK\n");
     293                 :            :     }
     294                 :          0 :     break;
     295                 :          0 :   default:   ERR("Unimplemented sign %c", se[1]); break;
     296                 :            :   }
     297                 :          0 :   sig = zx_zlib_raw_inflate(cf->ctx, len-(p-buf), p, &siglen);
     298                 :          0 :   printf("----- %03d %c%c %.*s\n", siglen, se[0], se[1], siglen, sig);  /* Inflated plain text */
     299                 :          0 :   ZX_FREE(cf->ctx, sig);
     300                 :          0 : }
     301                 :            : 
     302                 :            : /* ============== M A I N ============== */
     303                 :            : 
     304                 :            : /*(-) Control starts here */
     305                 :            : /* Called by: */
     306                 :            : int main(int argc, char** argv, char** env)
     307                 :          6 : {
     308                 :            :   RSA* rsa;
     309                 :            :   int len, seslen, ver;
     310                 :            :   char* p;
     311                 :            :   char* pp;
     312                 :            :   char se[4];
     313                 :            :   char ses[16];
     314                 :            :   char sha1[20];
     315                 :            :   struct aes_key_st aes_key;
     316                 :          6 :   zxid_conf* cf = zxid_new_conf(0);
     317                 :          6 :   strcpy(zx_instance, "\tzxlogview");
     318                 :          6 :   opt(&argc, &argv, &env);
     319                 :            :   
     320                 :            :   while (1) {
     321         [ +  + ]:        177 :     if (scanf("%2s %4095[^\n]\n", se, buf) <= 0) {
     322   [ +  +  -  + ]:          3 :       D("scanf unable to scan line. Presme end of file. %d", 0);
     323                 :          3 :       return 0;
     324                 :            :     }
     325                 :        174 :     len = strlen(buf);
     326   [ +  -  -  -  :        174 :     switch (se[1]) {
                -  -  - ]
     327                 :            :     case 'P':   /* Plain: neither compressed nor encrypted. */
     328                 :        174 :       printf("----+ %03d %c%c %.*s\n", len, se[0], se[1], len, buf);
     329                 :        174 :       p = strchr(buf, ' ');
     330         [ -  + ]:        174 :       if (!p) {
     331                 :          0 :         ERR("Separator space not found. Corrupt line(%.*s)", len, buf);
     332                 :          0 :         break;
     333                 :            :       }
     334                 :            :       
     335   [ +  -  -  -  :        174 :       switch (se[0]) {
                      - ]
     336                 :            :       case 'P':  /* No sig */
     337                 :        174 :         break;
     338                 :            :       case 'R':
     339                 :          0 :         pp = unbase64_raw(buf, p, buf, zx_std_index_64);  /* In place, overwrite. */
     340                 :          0 :         ++p;
     341                 :          0 :         ver = zxsig_verify_data(len-(p-buf), p, pp-buf, buf, log_verify_cert, "log vfy");
     342         [ #  # ]:          0 :         if (ver) {
     343                 :          0 :           printf("RSA signature FAIL. Log file may have been tampered - or bad certificate.\n");
     344                 :            :         } else {
     345                 :          0 :           printf("RSA signature OK\n");
     346                 :            :         }
     347                 :          0 :         break;
     348                 :          0 :       case 'D':  ERR("Unimplemented sign %c", se[1]); break;
     349                 :            :       case 'S':
     350                 :          0 :         unbase64_raw(buf, p, buf, zx_std_index_64);  /* In place, overwrite. */
     351                 :          0 :         ++p;
     352                 :          0 :         SHA1((unsigned char*)p, len-(p-buf), (unsigned char*)sha1);
     353         [ #  # ]:          0 :         if (memcmp(buf, sha1, 20)) {
     354                 :          0 :           printf("SHA1 FAIL\n");
     355                 :            :         } else {
     356                 :          0 :           printf("SHA1 OK\n");
     357                 :            :         }
     358                 :          0 :         break;
     359                 :          0 :       default:   ERR("Unimplemented sign %c", se[1]); break;
     360                 :            :       }
     361                 :        174 :       break;
     362                 :            : 
     363                 :            :     case 'A':  /* RSA-AES encrypted */
     364                 :          0 :       p = unbase64_raw(buf, buf+len, buf, zx_std_index_64);
     365                 :          0 :       len = p-buf;
     366   [ #  #  #  # ]:          0 :       D("unbase64 len(%d)", len);
     367                 :          0 :       seslen = (unsigned char)buf[0] << 8 | (unsigned char)buf[1];
     368   [ #  #  #  # ]:          0 :       D("seslen(%d)", seslen);
     369                 :            :       
     370                 :          0 :       rsa = EVP_PKEY_get1_RSA(log_decrypt_pkey);
     371         [ #  # ]:          0 :       if (!rsa) {
     372                 :          0 :         ERR("No RSA key found in log decryption key type=0x%x", log_decrypt_pkey->type);
     373                 :          0 :         break;
     374                 :            :       }
     375                 :          0 :       seslen = RSA_private_decrypt(seslen, (unsigned char*)buf+2, (unsigned char*)ses, rsa, RSA_PKCS1_OAEP_PADDING);
     376         [ #  # ]:          0 :       if (seslen < 0) {
     377                 :          0 :         ERR("RSA dec fail %x", seslen);
     378                 :          0 :         zx_report_openssl_error("zxlog rsa enc");
     379                 :          0 :         break;
     380                 :            :       }
     381   [ #  #  #  # ]:          0 :       D("decrypted session key len(%d)", seslen);
     382         [ #  # ]:          0 :       if (seslen != 16) {
     383                 :          0 :         ERR("Decrypted session key not right size(%d), should be 16.", seslen);
     384                 :          0 :         break;
     385                 :            :       }
     386                 :            :       
     387                 :          0 :       p = buf+2+seslen+16;
     388                 :          0 :       AES_set_decrypt_key((unsigned char*)ses, 128, &aes_key);
     389                 :          0 :       AES_cbc_encrypt((unsigned char*)p, (unsigned char*)p, len-(p-buf), &aes_key, (unsigned char*)buf+2+seslen,0);
     390                 :          0 :       zxlog_zsig_verify_print(cf, len, buf, se, p);
     391                 :          0 :       break;
     392                 :          0 :     case 'T':  ERR("Unimplemented decryption %c", se[1]); break;
     393                 :            :     case 'B':  /* Symmetric AES encrypted */
     394                 :          0 :       p = unbase64_raw(buf, buf+len, buf, zx_std_index_64);
     395                 :          0 :       len = p-buf;
     396   [ #  #  #  # ]:          0 :       D("unbase64 len(%d)", len);
     397                 :          0 :       p = buf+16;
     398                 :          0 :       AES_set_decrypt_key((unsigned char*)log_symkey, 128, &aes_key);
     399                 :          0 :       AES_cbc_encrypt((unsigned char*)p, (unsigned char*)p, len-16, &aes_key, (unsigned char*)buf, 0);
     400                 :          0 :       zxlog_zsig_verify_print(cf, len, buf, se, p);
     401                 :          0 :       break;
     402                 :          0 :     case 'U':  ERR("Unimplemented decryption %c", se[1]); break;
     403                 :            :     case 'Z':  /* RFC1951 zip + safe base64 only */
     404                 :          0 :       p = unbase64_raw(buf, buf+len, buf, zx_std_index_64);
     405                 :          0 :       len = p-buf;
     406   [ #  #  #  # ]:          0 :       D("unbase64 len(%d)", len);
     407                 :          0 :       zxlog_zsig_verify_print(cf, len, buf, se, buf);
     408                 :          0 :       break;
     409                 :          0 :     default:   ERR("Unknown decryption %c", se[1]); break;
     410                 :            :     }
     411                 :        174 :   }
     412                 :            :   return 0;
     413                 :            : }
     414                 :            : 
     415                 :            : //char* assert_msg = "%s: Internal error caused an ASSERT to fire. Deliberately provoking a core dump.\nSorry for the inconvenience.\n";
     416                 :            : 
     417                 :            : /* EOF  --  zxlogview.c */

Generated by: LCOV version 1.9