granicus.if.org Git - apache/blob - modules/ssl/ssl_engine_log.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*                      _             _
  18  *  _ __ ___   ___   __| |    ___ ___| |  mod_ssl
  19  * | '_ ` _ \ / _ \ / _` |   / __/ __| |  Apache Interface to OpenSSL
  20  * | | | | | | (_) | (_| |   \__ \__ \ |
  21  * |_| |_| |_|\___/ \__,_|___|___/___/_|
  22  *                      |_____|
  23  *  ssl_engine_log.c
  24  *  Logging Facility
  25  */
  26                              /* ``The difference between a computer
  27                                   industry job and open-source software
  28                                   hacking is about 30 hours a week.''
  29                                          -- Ralf S. Engelschall     */
  30 #include "ssl_private.h"
  31
  32 /*  _________________________________________________________________
  33 **
  34 **  Logfile Support
  35 **  _________________________________________________________________
  36 */
  37
  38 static const struct {
  39     const char *cpPattern;
  40     const char *cpAnnotation;
  41 } ssl_log_annotate[] = {
  42     { "*envelope*bad*decrypt*", "wrong pass phrase!?" },
  43     { "*CLIENT_HELLO*unknown*protocol*", "speaking not SSL to HTTPS port!?" },
  44     { "*CLIENT_HELLO*http*request*", "speaking HTTP to HTTPS port!?" },
  45     { "*SSL3_READ_BYTES:sslv3*alert*bad*certificate*", "Subject CN in certificate not server name or identical to CA!?" },
  46     { "*self signed certificate in certificate chain*", "Client certificate signed by CA not known to server?" },
  47     { "*peer did not return a certificate*", "No CAs known to server for verification?" },
  48     { "*no shared cipher*", "Too restrictive SSLCipherSuite or using DSA server certificate?" },
  49     { "*no start line*", "Bad file contents or format - or even just a forgotten SSLCertificateKeyFile?" },
  50     { "*bad password read*", "You entered an incorrect pass phrase!?" },
  51     { "*bad mac decode*", "Browser still remembered details of a re-created server certificate?" },
  52     { NULL, NULL }
  53 };
  54
  55 static const char *ssl_log_annotation(const char *error)
  56 {
  57     int i = 0;
  58
  59     while (ssl_log_annotate[i].cpPattern != NULL
  60            && ap_strcmp_match(error, ssl_log_annotate[i].cpPattern) != 0)
  61         i++;
  62
  63     return ssl_log_annotate[i].cpAnnotation;
  64 }
  65
  66 void ssl_die(void)
  67 {
  68     /*
  69      * This is used for fatal errors and here
  70      * it is common module practice to really
  71      * exit from the complete program.
  72      */
  73     exit(1);
  74 }
  75
  76 /*
  77  * Prints the SSL library error information.
  78  */
  79 void ssl_log_ssl_error(const char *file, int line, int level, server_rec *s)
  80 {
  81     unsigned long e;
  82     const char *data;
  83     int flags;
  84
  85     while ((e = ERR_peek_error_line_data(NULL, NULL, &data, &flags))) {
  86         const char *annotation;
  87         char err[256];
  88
  89         if (!(flags & ERR_TXT_STRING)) {
  90             data = NULL;
  91         }
  92
  93         ERR_error_string_n(e, err, sizeof err);
  94         annotation = ssl_log_annotation(err);
  95
  96         ap_log_error(file, line, APLOG_MODULE_INDEX, level, 0, s,
  97                      "SSL Library Error: %s%s%s%s%s%s",
  98                      /* %s */
  99                      err,
 100                      /* %s%s%s */
 101                      data ? " (" : "", data ? data : "", data ? ")" : "",
 102                      /* %s%s */
 103                      annotation ? " -- " : "",
 104                      annotation ? annotation : "");
 105
 106         /* Pop the error off the stack: */
 107         ERR_get_error();
 108     }
 109 }
 110
 111 static void ssl_log_cert_error(const char *file, int line, int level,
 112                                apr_status_t rv, const server_rec *s,
 113                                const conn_rec *c, const request_rec *r,
 114                                apr_pool_t *p, X509 *cert, const char *format,
 115                                va_list ap)
 116 {
 117     char buf[HUGE_STRING_LEN];
 118     int msglen, n;
 119     char *name;
 120
 121     apr_vsnprintf(buf, sizeof buf, format, ap);
 122
 123     msglen = strlen(buf);
 124
 125     if (cert) {
 126         BIO *bio = BIO_new(BIO_s_mem());
 127
 128         if (bio) {
 129             /*
 130              * Limit the maximum length of the subject and issuer DN strings
 131              * in the log message. 300 characters should always be sufficient
 132              * for holding both the timestamp, module name, pid etc. stuff
 133              * at the beginning of the line and the trailing information about
 134              * serial, notbefore and notafter.
 135              */
 136             int maxdnlen = (HUGE_STRING_LEN - msglen - 300) / 2;
 137
 138             BIO_puts(bio, " [subject: ");
 139             name = SSL_X509_NAME_to_string(p, X509_get_subject_name(cert),
 140                                            maxdnlen);
 141             if (!strIsEmpty(name)) {
 142                 BIO_puts(bio, name);
 143             } else {
 144                 BIO_puts(bio, "-empty-");
 145             }
 146
 147             BIO_puts(bio, " / issuer: ");
 148             name = SSL_X509_NAME_to_string(p, X509_get_issuer_name(cert),
 149                                            maxdnlen);
 150             if (!strIsEmpty(name)) {
 151                 BIO_puts(bio, name);
 152             } else {
 153                 BIO_puts(bio, "-empty-");
 154             }
 155
 156             BIO_puts(bio, " / serial: ");
 157             if (i2a_ASN1_INTEGER(bio, X509_get_serialNumber(cert)) == -1)
 158                 BIO_puts(bio, "(ERROR)");
 159
 160             BIO_puts(bio, " / notbefore: ");
 161             ASN1_TIME_print(bio, X509_get_notBefore(cert));
 162
 163             BIO_puts(bio, " / notafter: ");
 164             ASN1_TIME_print(bio, X509_get_notAfter(cert));
 165
 166             BIO_puts(bio, "]");
 167
 168             n = BIO_read(bio, buf + msglen, sizeof buf - msglen - 1);
 169             if (n > 0)
 170                buf[msglen + n] = '\0';
 171
 172             BIO_free(bio);
 173         }
 174     }
 175     else {
 176         apr_snprintf(buf + msglen, sizeof buf - msglen,
 177                      " [certificate: -not available-]");
 178     }
 179
 180     if (r) {
 181         ap_log_rerror(file, line, APLOG_MODULE_INDEX, level, rv, r, "%s", buf);
 182     }
 183     else if (c) {
 184         ap_log_cerror(file, line, APLOG_MODULE_INDEX, level, rv, c, "%s", buf);
 185     }
 186     else if (s) {
 187         ap_log_error(file, line, APLOG_MODULE_INDEX, level, rv, s, "%s", buf);
 188     }
 189
 190 }
 191
 192 /*
 193  * Wrappers for ap_log_error/ap_log_cerror/ap_log_rerror which log additional
 194  * details of the X509 cert. For ssl_log_xerror, a pool needs to be passed in
 195  * as well (for temporary allocation of the cert's subject/issuer name strings,
 196  * in the other cases we use the connection and request pool, respectively).
 197  */
 198 void ssl_log_xerror(const char *file, int line, int level, apr_status_t rv,
 199                     apr_pool_t *ptemp, server_rec *s, X509 *cert,
 200                     const char *fmt, ...)
 201 {
 202     if (APLOG_IS_LEVEL(s,level)) {
 203        va_list ap;
 204        va_start(ap, fmt);
 205        ssl_log_cert_error(file, line, level, rv, s, NULL, NULL, ptemp,
 206                           cert, fmt, ap);
 207        va_end(ap);
 208     }
 209 }
 210
 211 void ssl_log_cxerror(const char *file, int line, int level, apr_status_t rv,
 212                      conn_rec *c, X509 *cert, const char *fmt, ...)
 213 {
 214     if (APLOG_IS_LEVEL(mySrvFromConn(c),level)) {
 215        va_list ap;
 216        va_start(ap, fmt);
 217        ssl_log_cert_error(file, line, level, rv, NULL, c, NULL, c->pool,
 218                           cert, fmt, ap);
 219        va_end(ap);
 220     }
 221 }
 222
 223 void ssl_log_rxerror(const char *file, int line, int level, apr_status_t rv,
 224                      request_rec *r, X509 *cert, const char *fmt, ...)
 225 {
 226     if (APLOG_R_IS_LEVEL(r,level)) {
 227        va_list ap;
 228        va_start(ap, fmt);
 229        ssl_log_cert_error(file, line, level, rv, NULL, NULL, r, r->pool,
 230                           cert, fmt, ap);
 231        va_end(ap);
 232     }
 233 }