开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Web服务器 > 查看源码
ssl.c
资源名称：phttpd-1.10.04.tar.gz　[点击查看]
上传用户：ladybrid91
上传日期：2007-01-04
资源大小：287k
文件大小：25k
源码类别：

Web服务器

开发平台：

Unix_Linux

ssl.c：源码内容
  1. /* ====================================================================
  2.  * Copyright (c) 1995, 1996, 1997 Ben Laurie.  All rights reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions
  6.  * are met:
  7.  *
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer. 
  10.  *
  11.  * 2. Redistributions in binary form must reproduce the above copyright
  12.  *    notice, this list of conditions and the following disclaimer in
  13.  *    the documentation and/or other materials provided with the
  14.  *    distribution.
  15.  *
  16.  * 3. All advertising materials mentioning features or use of this
  17.  *    software must display the following acknowledgment:
  18.  *    "This product includes software developed by Ben Laurie
  19.  *    for use in the Apache-SSL HTTP server project."
  20.  *
  21.  * 4. The name "Apache-SSL Server" must not be used to
  22.  *    endorse or promote products derived from this software without
  23.  *    prior written permission.
  24.  *
  25.  * 5. Redistributions of any form whatsoever must retain the following
  26.  *    acknowledgment:
  27.  *    "This product includes software developed by Ben Laurie
  28.  *    for use in the Apache-SSL HTTP server project."
  29.  *
  30.  * THIS SOFTWARE IS PROVIDED BY BEN LAURIE ``AS IS'' AND ANY
  31.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  32.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  33.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL BEN LAURIE OR
  34.  * HIS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  35.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  36.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  37.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  40.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  41.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  42.  * ====================================================================
  43.  *
  44.  * This software consists of patches to the Apache HTTP server interfacing it
  45.  * to SSLeay.
  46.  * For more information on Apache-SSL, contact Ben Laurie <ben@algroup.co.uk>.
  47.  *
  48.  * For more information on Apache see http://www.apache.org.
  49.  *
  50.  * For more information on SSLeay see http://www.psy.uq.oz.au/~ftp/Crypto/.
  51.  *
  52.  */
  54. #include <stdio.h>
  55. #include <stdlib.h>
  56. #include <stdarg.h>
  57. #include <assert.h>
  59. #include <ssl.h>
  60. #include <err.h>
  61. #include <x509.h>
  62. #include <pem.h>
  63. #include <crypto.h>
  65. #include "httpd.h"
  66. #include "http_config.h"
  67. #include "http_log.h"
  69. #if SSLEAY_VERSION_NUMBER < 0x600
  70. #define ERR_print_errors_fp ERR_print_errors
  71. #endif
  73. #if SSLEAY_VERSION_NUMBER < 0x0800
  74. #define X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY 
  75. VERIFY_ERR_UNABLE_TO_GET_ISSUER
  76. #define X509_V_OK VERIFY_OK
  77. #define SSL_CTX_set_default_verify_paths(ctx) SSL_set_default_verify_paths(ctx)
  78. #define SSL_CTX_load_verify_locations(ctx,cafile,capath) 
  79.  SSL_load_verify_locations(ctx,cafile,capath)
  80. #define X509_verify_cert_error_string(error) X509_cert_verify_error_string(error)
  81. #endif
  83. #if !defined(SSL_TXT_NULL)
  84. /* text strings for the ciphers */
  85. #define SSL_TXT_NULL_WITH_MD5 SSL2_TXT_NULL_WITH_MD5
  86. #define SSL_TXT_RC4_128_WITH_MD5 SSL2_TXT_RC4_128_WITH_MD5
  87. #define SSL_TXT_RC4_128_EXPORT40_WITH_MD5 SSL2_TXT_RC4_128_EXPORT40_WITH_MD5
  88. #define SSL_TXT_RC2_128_CBC_WITH_MD5 SSL2_TXT_RC2_128_CBC_WITH_MD5
  89. #define SSL_TXT_RC2_128_CBC_EXPORT40_WITH_MD5 SSL2_TXT_RC2_128_CBC_EXPORT40_WITH_MD5
  90. #define SSL_TXT_IDEA_128_CBC_WITH_MD5 SSL2_TXT_IDEA_128_CBC_WITH_MD5
  91. #define SSL_TXT_DES_64_CBC_WITH_MD5 SSL2_TXT_DES_64_CBC_WITH_MD5
  92. #define SSL_TXT_DES_64_CBC_WITH_SHA SSL2_TXT_DES_64_CBC_WITH_SHA
  93. #define SSL_TXT_DES_192_EDE3_CBC_WITH_MD5 SSL2_TXT_DES_192_EDE3_CBC_WITH_MD5
  94. #define SSL_TXT_DES_192_EDE3_CBC_WITH_SHA SSL2_TXT_DES_192_EDE3_CBC_WITH_SHA
  96. #define SSL_TXT_DES_64_CFB64_WITH_MD5_1 SSL2_TXT_DES_64_CFB64_WITH_MD5_1
  97. #define SSL_TXT_NULL SSL2_TXT_NULL
  98. #endif
  100. #ifndef SSL_TXT_DES_64_CFB64_WITH_MD5_1
  101. /* SSLeay 0.8.0 misses this definition */
  102. #define SSL_TXT_DES_64_CFB64_WITH_MD5_1 SSL2_TXT_DES_64_CFB64_WITH_MD5_1
  103. #endif
  105. typedef enum
  106.     {
  107.     VERIFY_NONE=0,
  108.     VERIFY_OPTIONAL=1,
  109.     VERIFY_REQUIRE=2,
  110.     VERIFY_OPTIONAL_NO_CA=3
  111.     } VerifyType;
  113. typedef struct
  114.     {
  115.     BOOL bDisabled;
  117.     char *szCertificateFile;
  118.     char *szKeyFile;
  119.     char *szCACertificatePath;
  120.     char *szCACertificateFile;
  121.     char *szLogFile;
  122.     char *szReqCiphers;
  123.     FILE *fileLogFile;
  124.     int nVerifyDepth;
  125.     VerifyType nVerifyClient;
  127.     X509 *px509Certificate;
  128.     RSA *prsaKey;
  130.     SSL_CTX *pSSLCtx;
  132.     BOOL bFakeBasicAuth;
  133.     } SSLConfigRec;
  135. typedef struct
  136.     {
  137.     /* 1) If cipher is banned, refuse */
  138.     /* 2) If RequiredCiphers is NULL, accept */
  139.     /* 3) If the cipher isn't required, refuse */
  141.     table *tbRequiredCiphers;
  142.     table *tbBannedCiphers;
  143.     } SSLDirConfigRec;
  145. extern module ssl_module;
  147. static conn_rec *SSLVerifyConn;
  149. static const char *SSLRequireCipher(cmd_parms *cmd,SSLDirConfigRec *rec,char *cipher)
  150.     {
  151.     table_set(rec->tbRequiredCiphers,cipher,"Required");
  152.     return NULL;
  153.     }
  155. static const char *SSLBanCipher(cmd_parms *cmd,SSLDirConfigRec *rec,char *cipher)
  156.     {
  157.     table_set(rec->tbBannedCiphers,cipher,"Banned");
  158.     return NULL;
  159.     }
  161. static int SSLCheckCipher(request_rec *r)
  162.     {
  163.     char *cipher;
  164.     SSLDirConfigRec *rec=(SSLDirConfigRec *)
  165.       get_module_config(r->per_dir_config,&ssl_module);
  166.     SSLConfigRec *pConfig=(SSLConfigRec *)
  167.       get_module_config(r->server->module_config,&ssl_module);
  169.     /* Check to see if SSL is on */
  170.     if(pConfig->bDisabled)
  171. return DECLINED;
  173.     cipher=SSL_get_cipher(r->connection->client->ssl);
  175.     if(table_get(rec->tbBannedCiphers,cipher))
  176. {
  177. char *buf;
  179. buf=pstrcat(r->pool,"Cipher ",cipher," is forbidden",NULL);
  180. log_reason(buf,r->filename,r);
  181. return FORBIDDEN;
  182. }
  183.     if(table_get(rec->tbRequiredCiphers,cipher))
  184. return OK;
  186.     if(rec->tbRequiredCiphers->nelts == 0)
  187. return OK;
  188.     else
  189. {
  190. char *buf;
  192. buf=pstrcat(r->pool,"Cipher ",cipher," is not on the permitted list",
  193.     NULL);
  194. log_reason(buf,r->filename,r);
  195. return FORBIDDEN;
  196. }
  197.     }
  199. int SSLFixups (request_rec *r)
  200.     {
  201.     table *e=r->subprocess_env;
  202.     int keysize=0;
  203.     int secretkeysize=0;
  204.     char buf[MAX_STRING_LEN];
  205.     char *cipher;
  207.     SSLConfigRec *pConfig=(SSLConfigRec *)
  208.       get_module_config(r->server->module_config,&ssl_module);
  210.     /* Check to see if SSL is on */
  211.     if(pConfig->bDisabled)
  212. return DECLINED;
  214.     cipher=SSL_get_cipher(r->connection->client->ssl);
  215.     table_set(e,"HTTPS","on");
  216.     table_set(e,"HTTPS_CIPHER",cipher);
  218.     if(!strcmp(cipher,SSL_TXT_NULL_WITH_MD5))
  219. keysize=secretkeysize=0;
  220.     else if(!strcmp(cipher,SSL_TXT_RC4_128_WITH_MD5))
  221. keysize=secretkeysize=128;
  222.     else if(!strcmp(cipher,SSL_TXT_RC4_128_EXPORT40_WITH_MD5))
  223. { keysize=128; secretkeysize=40; }
  224.     else if(!strcmp(cipher,SSL_TXT_RC2_128_CBC_WITH_MD5))
  225. keysize=secretkeysize=128;
  226.     else if(!strcmp(cipher,SSL_TXT_RC2_128_CBC_EXPORT40_WITH_MD5))
  227. { keysize=128; secretkeysize=40; }
  228.     else if(!strcmp(cipher,SSL_TXT_IDEA_128_CBC_WITH_MD5))
  229. keysize=secretkeysize=128;
  230.     else if(!strcmp(cipher,SSL_TXT_DES_64_CBC_WITH_MD5))
  231. keysize=secretkeysize=64;
  232.     else if(!strcmp(cipher,SSL_TXT_DES_64_CBC_WITH_SHA))
  233. keysize=secretkeysize=64;
  234.     else if(!strcmp(cipher,SSL_TXT_DES_192_EDE3_CBC_WITH_MD5))
  235. keysize=secretkeysize=192;
  236.     else if(!strcmp(cipher,SSL_TXT_DES_192_EDE3_CBC_WITH_SHA))
  237. keysize=secretkeysize=192;
  238.     else if(!strcmp(cipher,SSL_TXT_DES_64_CFB64_WITH_MD5_1))
  239. keysize=secretkeysize=64;
  240.     else if(!strcmp(cipher,SSL_TXT_NULL))
  241. keysize=secretkeysize=0;
  243.     sprintf(buf,"%d",keysize);
  244.     table_set(e,"HTTPS_KEYSIZE",buf);
  246.     sprintf(buf,"%d",secretkeysize);
  247.     table_set(e,"HTTPS_SECRETKEYSIZE",buf);
  249.     if(r->connection->client->szClientX509)
  250. table_set(e,"SSL_CLIENT_DN",r->connection->client->szClientX509);
  252.     return OK;
  253.     }
  255. static void SSLLogError(server_rec *s)
  256.     {
  257.     unsigned long l;
  258.     char buf[MAX_STRING_LEN];
  260.     /* Print out error messages */
  262.     while((l=ERR_get_error()))
  263.       {
  264. ERR_error_string(l,buf);
  265. log_error(buf,s);
  266.       }
  267.     }
  269. static void *CreateSSLServerConfig(pool *p,server_rec *s)
  270.     {
  271.     SSLConfigRec *rec=pcalloc(p,sizeof(SSLConfigRec));
  272.     
  273.     rec->bDisabled=FALSE;
  274.     rec->szCertificateFile=rec->szKeyFile=rec->szLogFile=NULL;
  275.     rec->nVerifyDepth=0;
  276.     rec->nVerifyClient=VERIFY_NONE;
  277.     rec->px509Certificate=NULL;
  278.     rec->prsaKey=NULL;
  279.     rec->bFakeBasicAuth=FALSE;
  280.     return rec;
  281.     }
  283. static void *CreateSSLDirConfig(pool *p,char *dummy)
  284.     {
  285.     SSLDirConfigRec *rec=pcalloc(p,sizeof(SSLDirConfigRec));
  287.     rec->tbRequiredCiphers=make_table(p,4);
  288.     rec->tbBannedCiphers=make_table(p,4);
  290.     return rec;
  291.     }
  293. static void *MergeSSLDirConfig(pool *p,void *basev,void *addv)
  294.     {
  295.     SSLDirConfigRec *base=(SSLDirConfigRec *)basev;
  296.     SSLDirConfigRec *add=(SSLDirConfigRec *)addv;
  297.     SSLDirConfigRec *new=(SSLDirConfigRec *)palloc(p,sizeof(SSLDirConfigRec));
  299.     new->tbRequiredCiphers=overlay_tables(p,add->tbRequiredCiphers,
  300.     base->tbRequiredCiphers);
  301.     new->tbBannedCiphers=overlay_tables(p,add->tbBannedCiphers,
  302.   base->tbBannedCiphers);
  303.     return new;
  304.     }
  306. static void InitSSL()
  307.     {
  308.     char *CAfile=NULL,*CApath=NULL;
  310.     SSL_load_error_strings();
  311.     ERR_load_crypto_strings();
  312. #if SSLEAY_VERSION_NUMBER >= 0x0800
  313.     SSLeay_add_ssl_algorithms();
  314. #else
  315.     SSL_debug("/tmp/ssldebug");
  316. #endif
  317.     }
  319. #if SSLEAY_VERSION_NUMBER >= 0x0800
  320. /* FIXME: This is an expensive operation which should probably be done before
  321. forking */
  322. static RSA *TmpRSACallback(SSL *pSSL,int nExport)
  323.     {
  324.     static RSA *pRSA=NULL;
  326.     if (pRSA == NULL)
  327. pRSA=RSA_generate_key(512,RSA_F4,NULL);
  328.     return pRSA;
  329.     }
  330. #endif
  332. #if SSLEAY_VERSION_NUMBER >= 0x0800
  333. int ApacheSSLVerifyCallback(int ok,X509_STORE_CTX *ctx)
  334.     {
  335.     X509 *xs=X509_STORE_CTX_get_current_cert(ctx);
  336.     int depth=X509_STORE_CTX_get_error_depth(ctx);
  337.     int error=X509_STORE_CTX_get_error(ctx);
  338. #else
  339. int ApacheSSLVerifyCallback(int ok,X509 *xs,X509 *xi,int depth,int error)
  340.     {
  341. #endif
  342.     char *s;
  343.     SSLConfigRec *pConfig=get_module_config(SSLVerifyConn->server->module_config,&ssl_module);
  345. #if SSLEAY_VERSION_NUMBER < 0x0800
  346.     s=(char *)X509_NAME_oneline(X509_get_subject_name(xs));
  347. #else
  348.     s=(char *)X509_NAME_oneline(X509_get_subject_name(xs),NULL,0);
  349. #endif
  351.     if(s == NULL)
  352. {
  353. ERR_print_errors_fp(pConfig->fileLogFile);
  354. return(0);
  355. }
  356.     if(depth == 0)
  357. SSLVerifyConn->client->szClientX509=pstrdup(SSLVerifyConn->pool,s);
  359.     fprintf(pConfig->fileLogFile,"depth=%d %sn",depth,s);
  360.     free(s);
  361.     if(error == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY)
  362. {
  363. if(pConfig->nVerifyClient == VERIFY_OPTIONAL_NO_CA)
  364.     {
  365.     fprintf(pConfig->fileLogFile,"no issuer, returning OKn");
  366.     return TRUE;
  367.     }
  368. #if SSLEAY_VERSION_NUMBER < 0x0800
  369. s=(char *)X509_NAME_oneline(X509_get_issuer_name(xs));
  370. #else
  371. s=(char *)X509_NAME_oneline(X509_get_issuer_name(xs),NULL,0);
  372. #endif
  373. if(s == NULL)
  374.     {
  375.     fprintf(pConfig->fileLogFile,"verify errorn");
  376.     ERR_print_errors_fp(pConfig->fileLogFile);
  377.     SSLLogError(SSLVerifyConn->server);
  378.     return(0);
  379.     }
  380. fprintf(pConfig->fileLogFile,"issuer= %sn",s);
  381. free(s);
  382. }
  383.     if(!ok)
  384. {
  385. fprintf(pConfig->fileLogFile,"verify error:num=%d:%sn",error,
  386. X509_verify_cert_error_string(error));
  387. SSLLogError(SSLVerifyConn->server);
  388. SSLVerifyConn->client->szClientX509=NULL;
  389. }
  390.     if(depth >= pConfig->nVerifyDepth)
  391. {
  392. fprintf(pConfig->fileLogFile,"Verify depth exceededn");
  393. log_error("Verify depth exceeded",SSLVerifyConn->server);
  394. ok=0;
  395. }
  396.     fprintf(pConfig->fileLogFile,"verify return:%dn",ok);
  397.     return(ok);
  398.     }
  400. static int VerifyFlags(SSLConfigRec *pConfig)
  401.     {
  402.     int nVerify=0;
  404.     switch(pConfig->nVerifyClient)
  405. {
  406.     case VERIFY_REQUIRE:
  407. nVerify|=SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
  408. break;
  410.     case VERIFY_OPTIONAL:
  411.     case VERIFY_OPTIONAL_NO_CA:
  412. nVerify|=SSL_VERIFY_PEER;
  413. break;
  414. }
  415.     return nVerify;
  416.     }
  418. static void GetCertificateAndKey(server_rec *s,SSLConfigRec *pConfig)
  419.     {
  420.     char buf[1024],prompt[1024];
  421.     int n;
  422.     FILE *f;
  423.     char szPath[MAX_STRING_LEN];
  426.     if(pConfig->px509Certificate)
  427. {
  428. fprintf(stderr,"Attempt to reinitialise SSL for server %sn",
  429. s->server_hostname);
  430. return;
  431. }
  433.     fprintf(stderr,"Reading certificate and key for server %s:%dn",
  434.     s->server_hostname,s->port);
  436. #if SSLEAY_VERSION_NUMBER < 0x0800
  437.     pConfig->pSSLCtx=SSL_CTX_new();
  438. #else
  439.     pConfig->pSSLCtx=SSL_CTX_new(SSLv23_server_method());
  440.     SSL_CTX_set_verify(pConfig->pSSLCtx,VerifyFlags(pConfig),ApacheSSLVerifyCallback);
  441. #endif
  443.     if(pConfig->szReqCiphers != NULL)
  444. {
  445. if(!SSL_CTX_set_cipher_list(pConfig->pSSLCtx,pConfig->szReqCiphers))
  446.     {
  447.     fprintf(stderr,"unable to set ciphersn");
  448.     ERR_print_errors_fp(stderr);
  449.     SSLLogError(s);
  450.     }
  451. }
  453.     if(!SSL_CTX_load_verify_locations(pConfig->pSSLCtx,
  454.   pConfig->szCACertificateFile,
  455.   pConfig->szCACertificatePath)
  456.        || !SSL_CTX_set_default_verify_paths(pConfig->pSSLCtx))
  457.        {
  458.        fprintf(stderr,"error seting default verify locationsn");
  459.        ERR_print_errors_fp(stderr);
  460.        exit(1);
  461.        }
  463.     f=fopen(pConfig->szCertificateFile,"r");
  464.     if(!f)
  465. {
  466. sprintf(szPath,"%s/%s",X509_get_default_cert_dir(),
  467. pConfig->szCertificateFile);
  468. f=fopen(szPath,"r");
  469. if(!f)
  470.     {
  471.     fprintf(stderr,"Can't open certificate file %s, nor %sn",
  472.     pConfig->szCertificateFile,szPath);
  473.     exit(1);
  474.     }
  475. }
  476.     else
  477. strcpy(szPath,pConfig->szCertificateFile);  /* in case it also contains the key */
  479.     pConfig->px509Certificate=X509_new();
  481.     if(!PEM_read_X509(f,&pConfig->px509Certificate,NULL))
  482. {
  483. fprintf(stderr,"Error reading server certificate file %s: ",szPath);
  484. ERR_print_errors_fp(stderr);
  485. exit(1);
  486. }
  487.     fclose(f);
  489.     if(pConfig->szKeyFile)
  490. if(*pConfig->szKeyFile == '/')
  491.     strcpy(szPath,pConfig->szKeyFile);
  492. else
  493.     sprintf(szPath,"%s/private/%s",X509_get_default_cert_area(),
  494.     pConfig->szKeyFile);
  496. /* Otherwise the path already contains the name of the certificate file */
  497.     f=fopen(szPath,"r");
  498.     if(!f)
  499. {
  500. fprintf(stderr,"Can't open key file ");
  501. perror(szPath);
  502. exit(1);
  503. }
  505.     pConfig->prsaKey=RSA_new();
  506.     if(!PEM_read_RSAPrivateKey(f,&pConfig->prsaKey,NULL))
  507. {
  508. fprintf(stderr,"Error reading private key file %s: ",szPath);
  509. ERR_print_errors_fp(stderr);
  510. exit(1);
  511. }
  513. #if SSLEAY_VERSION_NUMBER >= 0x0800
  514.     SSL_CTX_set_tmp_rsa_callback(pConfig->pSSLCtx,TmpRSACallback);
  515.     /* Really this should have its own directive and list, but I haven't got
  516.        the time at the moment.
  517.      */
  518.     SSL_CTX_set_client_CA_list(pConfig->pSSLCtx, 
  519.     SSL_load_client_CA_file(pConfig->szCACertificateFile)); 
  520. #endif
  521.     }
  523. static void InitSSLServer(server_rec *s,pool *p)
  524.     {
  525.     InitSSL();
  526.     for ( ; s ; s=s->next)
  527. {
  528. SSLConfigRec *pConfig=get_module_config(s->module_config,&ssl_module);
  530. if(pConfig->bDisabled)
  531.     {
  532.     if(!s->port)
  533. s->port=HTTP_PORT;
  534.     fprintf(stderr,"SSL disabled for server %s:%dn",
  535.     s->server_hostname,s->port);
  536.     continue;
  537.     }
  539. if(!s->port)
  540.     s->port=HTTPS_PORT;
  542. if(!pConfig->szCertificateFile)
  543.     {
  544.     fprintf(stderr,"No SSL Certificate set for server %s:%dn",
  545.     s->server_hostname,s->port);
  546.     exit(1);
  547.     }
  548. if(pConfig->nVerifyClient < 0 || pConfig->nVerifyClient > VERIFY_OPTIONAL_NO_CA)
  549.     {
  550.     fprintf(stderr,"Bad value for SSLVerifyClient (%d)n",pConfig->nVerifyClient);
  551.     exit(1);
  552.     }
  553. if(!pConfig->szLogFile)
  554.     {
  555.     fprintf(stderr,"Required SSLLogFile missingn");
  556.     exit(1);
  557.     }
  559. pConfig->fileLogFile=fopen(pConfig->szLogFile,"a");
  560. if(!pConfig->fileLogFile)
  561.     {
  562.     perror(pConfig->szLogFile);
  563.     exit(1);
  564.     }
  565. setbuf(pConfig->fileLogFile,NULL);
  566.     
  567. GetCertificateAndKey(s,pConfig);
  568. }
  569.     }
  571. static const char *set_server_string_slot (cmd_parms *cmd,char *struct_ptr,char *arg)
  572.     {
  573.     /* This one should be pretty generic... */
  574.     char *pConfig=get_module_config(cmd->server->module_config,&ssl_module);
  575.   
  576.     int offset=(int)cmd->info; 
  577.     *(char **)(pConfig+offset)=arg;
  578.     return NULL;
  579.     }
  581. static const char *set_server_int_slot (cmd_parms *cmd,char *struct_ptr,char *arg)
  582.     {
  583.   /* This one should be pretty generic... */
  584.     char *pConfig=get_module_config(cmd->server->module_config,&ssl_module);
  585.   
  586.     int offset=(int)cmd->info; 
  587.     *(int *)(pConfig+offset)=atoi(arg);
  588.     return NULL;
  589.     }
  591. static const char *set_server_bool_slot (cmd_parms *cmd,char *struct_ptr)
  592.     {
  593.   /* This one should be pretty generic... */
  594.     char *pConfig=get_module_config(cmd->server->module_config,&ssl_module);
  595.   
  596.     int offset=(int)cmd->info; 
  597.     *(BOOL *)(pConfig+offset)=TRUE;
  598.     return NULL;
  599.     }
  601. command_rec ssl_cmds[]=
  602.     {
  603.     { "SSLDisable",set_server_bool_slot,
  604.       (void *)XtOffsetOf(SSLConfigRec,bDisabled),RSRC_CONF,NO_ARGS,
  605.       "Enable SSL" },
  606.     { "SSLCertificateFile",set_server_string_slot,
  607.       (void *)XtOffsetOf(SSLConfigRec,szCertificateFile),RSRC_CONF,TAKE1,
  608.       "PEM certificate file" },
  609.     { "SSLCertificateKeyFile",set_server_string_slot,
  610.       (void *)XtOffsetOf(SSLConfigRec,szKeyFile),RSRC_CONF,TAKE1,
  611.       "Certificate private key file (assumed to be SSLCertificateFile if absent)" },
  612.     { "SSLCACertificatePath",set_server_string_slot,
  613.       (void *)XtOffsetOf(SSLConfigRec,szCACertificatePath),RSRC_CONF,TAKE1,
  614.       "CA Certificate path (taken from SSL_CERT_DIR if absent)" },
  615.     { "SSLCACertificateFile",set_server_string_slot,
  616.       (void *)XtOffsetOf(SSLConfigRec,szCACertificateFile),RSRC_CONF,TAKE1,
  617.       "CA Certificate file (taken from SSL_CERT_FILE if absent)" },
  618.     { "SSLVerifyDepth",set_server_int_slot,
  619.       (void *)XtOffsetOf(SSLConfigRec,nVerifyDepth),RSRC_CONF,TAKE1,
  620.       "Verify depth (default 0)" },
  621.     { "SSLVerifyClient",set_server_int_slot,
  622.       (void *)XtOffsetOf(SSLConfigRec,nVerifyClient),RSRC_CONF,TAKE1,
  623.       "Verify client (0=no,1=optional,2=required" },
  624.     { "SSLFakeBasicAuth",set_server_bool_slot,
  625.       (void *)XtOffsetOf(SSLConfigRec,bFakeBasicAuth),RSRC_CONF,NO_ARGS,
  626.       "Translate client X509 into a user name" },
  627.     { "SSLLogFile",set_server_string_slot,
  628.       (void *)XtOffsetOf(SSLConfigRec,szLogFile),RSRC_CONF,TAKE1,
  629.       "Place to dump all SSL messages that have no better home" },
  630.     { "SSLRequiredCiphers",set_server_string_slot,
  631.       (void *)XtOffsetOf(SSLConfigRec,szReqCiphers),RSRC_CONF,TAKE1,
  632.       "Colon-delimited list of required ciphers" },
  633.     /* Per Directory */
  634.     { "SSLRequireCipher",SSLRequireCipher,NULL,OR_FILEINFO,ITERATE,
  635.       "add a cipher to the per directory list of required ciphers" },
  636.     { "SSLBanCipher",SSLBanCipher,NULL,OR_FILEINFO,ITERATE,
  637.       "add a cipher to the per directory list of banned ciphers" },
  638.     { NULL },
  639.     };
  641. static const char six2pr[64+1]=
  642.   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  644. void uuencode(char *szTo,const char *szFrom)
  645.     {
  646.     const unsigned char *s;
  648.     for(s=(const unsigned char *)szFrom ; *s ; s+=3)
  649. {
  650. *szTo++=six2pr[s[0] >> 2];
  651. *szTo++=six2pr[(s[0] << 4 | s[1] >> 4)&0x3f];
  652. if(!s[0])
  653.     break;
  654. *szTo++=six2pr[(s[1] << 2 | s[2] >> 6)&0x3f];
  655. if(!s[1])
  656.     break;
  657. *szTo++=six2pr[s[2]&0x3f];
  658. if(!s[2])
  659.     break;
  660. }
  661.     *szTo++='';
  662.     }
  664. /*
  665. Fake a Basic authentication from the X509 client certificate.
  667. This must be run fairly early on to prevent a real authentication from
  668. occuring, in particular it must be run before anything else that authenticates
  669. a user.
  671. This means that the Module statement for this module should be LAST in the
  672. Configuration file.
  673. */
  675. static int FakeBasicAuth(request_rec *r)
  676.     {
  677.     SSLConfigRec *pConfig=get_module_config(r->server->module_config,&ssl_module);
  678.     char b1[MAX_STRING_LEN],b2[MAX_STRING_LEN];
  679.   
  680.     if(!pConfig->bFakeBasicAuth)
  681. return DECLINED;
  682.     if(r->connection->user)
  683. return DECLINED;
  684.     if(!r->connection->client->szClientX509)
  685. return DECLINED;
  686.     /*
  687.        Fake a password - which one would be immaterial, as, it seems, an empty
  688.        password in the users file would match ALL incoming passwords, if only we
  689.        were using the standard crypt library routine. Unfortunately, SSLeay
  690.        "fixes" a "bug" in crypt and thus prevents blank passwords from working.
  691.        (IMHO what they really fix is a bug in the users of the code - failing to
  692.        program correctly for shadow passwords).
  693.        We need, therefore, to provide a password. This password can be matched by
  694.        adding the string "xxj31ZMTZzkVA" as the password in the user file.
  695. */
  696.     sprintf(b1,"%s:password",r->connection->client->szClientX509);
  697.     uuencode(b2,b1);
  698.     sprintf(b1,"Basic %s",b2);
  699.     table_set(r->headers_in,"Authorization",b1);
  700.     return DECLINED;
  701.     }
  703. static BOOL ApacheSSLSetCertStuff(conn_rec *conn)
  704.     {
  705.     SSLConfigRec *pConfig=get_module_config(conn->server->module_config,
  706.     &ssl_module);
  707.     SSL *con=conn->client->ssl;
  708.     char *cert_file=pConfig->szCertificateFile;
  709.     char *key_file=pConfig->szKeyFile;
  711. /*  PEM_set_getkey_callback(ApacheSSLKeyCallback); */
  712.     if(cert_file != NULL)
  713. {
  714. if(SSL_use_certificate(con,pConfig->px509Certificate) <= 0)
  715.     {
  716.     fprintf(pConfig->fileLogFile,"unable to set certificaten");
  717.     ERR_print_errors_fp(pConfig->fileLogFile);
  718.     SSLLogError(conn->server);
  719.     return FALSE;
  720.     }
  721. if(SSL_use_RSAPrivateKey(con,pConfig->prsaKey) <= 0)
  722.     {
  723.     fprintf(pConfig->fileLogFile,"unable to set private keyn");
  724.     ERR_print_errors_fp(pConfig->fileLogFile);
  725.     SSLLogError(conn->server);
  726.     return FALSE;
  727.     }
  728. }
  729.     return TRUE;
  730.     }
  732. void ApacheSSLSetupVerify(conn_rec *conn)
  733.     {
  734.     SSLConfigRec *pConfig=get_module_config(conn->server->module_config,&ssl_module);
  735.     int nVerify=VerifyFlags(pConfig);
  737.     conn->client->szClientX509=NULL;
  739.     SSLVerifyConn=conn;
  741.     conn->client->nVerifyError=X509_V_OK;
  743. /* Why call this twice?? Ben */  
  744. #if SSLEAY_VERSION_NUMBER < 0x0800
  745.     SSL_set_verify(conn->client->ssl,nVerify,ApacheSSLVerifyCallback);
  746. #endif
  747.     if(!ApacheSSLSetCertStuff(conn))
  748. {
  749. fprintf(pConfig->fileLogFile,"ApacheSSLSetCertStuff failedn");
  750. log_error("ApacheSSLSetCertStuff failed",conn->server);
  751. exit(1);
  752. }
  753. #if SSLEAY_VERSION_NUMBER >= 0x0800
  754. #else
  755.     SSL_set_verify(conn->client->ssl,nVerify,ApacheSSLVerifyCallback);
  756. #endif
  757.     }
  759. int ApacheSSLSetupConnection(conn_rec * conn)
  760.     {
  761.     server_rec * srvr=conn->server;
  762.     BUFF * fb=conn->client;
  763.     SSLConfigRec *pConfig=get_module_config(srvr->module_config,
  764.       &ssl_module);
  765.     char *cert_file=pConfig->szCertificateFile;
  766.     char *key_file=pConfig->szKeyFile;
  768.     if(pConfig->bDisabled)
  769. {
  770. fb->ssl=NULL;
  771. return TRUE;
  772. }
  773.     
  774.     SSLVerifyConn=conn;
  776.     fb->ssl=SSL_new(pConfig->pSSLCtx);
  777.     SSL_set_fd(fb->ssl,fb->fd);
  779. #if 0
  780.     if (cert_file != NULL) {
  781. if (SSL_use_certificate(fb->ssl,pConfig->px509Certificate) <= 0) {
  782.     fprintf(pConfig->fileLogFile,"unable to set certificaten");
  783.     ERR_print_errors_fp(pConfig->fileLogFile);
  784.     SSLLogError(srvr);
  785.     fb->flags |= B_EOF | B_EOUT;
  786.     return FALSE;
  787. }
  789. if(SSL_use_RSAPrivateKey(fb->ssl,pConfig->prsaKey) <= 0) {
  790.     fprintf(pConfig->fileLogFile,"unable to set private keyn");
  791.     ERR_print_errors_fp(pConfig->fileLogFile);
  792.     SSLLogError(srvr);
  793.     fb->flags |= B_EOF | B_EOUT;
  794.     return FALSE;
  795. }
  797.     }
  798. #endif
  799.     ApacheSSLSetupVerify(conn);
  801.     while(!SSL_is_init_finished(fb->ssl))
  802. {
  803. int ret=SSL_accept(fb->ssl);
  804. if (ret <= 0)
  805.     {
  806.     log_error("SSL_Accept failed",srvr);
  807.     SSLLogError(srvr);
  808.     fb->flags |= B_EOF | B_EOUT;
  809.     return FALSE;
  810.     }
  812. if(conn->client->nVerifyError != X509_V_OK)
  813.     {
  814.     log_error("Verification failed",conn->server);
  815.     SSLLogError(srvr);
  816.     fb->flags |= B_EOF | B_EOUT;
  817.     return FALSE;
  818.     }
  820. if(pConfig->nVerifyClient == VERIFY_REQUIRE && !conn->client->szClientX509)
  821.     {
  822.     log_error("No client certificate",conn->server);
  823.     SSLLogError(conn->server);
  824.     return 0;
  825.     }
  826. fprintf(pConfig->fileLogFile,"CIPHER is %sn",SSL_get_cipher(conn->client->ssl));
  827. fflush(pConfig->fileLogFile);
  828. }
  830.     /* This should be safe.... so I'll use it */
  831.     SSL_set_read_ahead(fb->ssl,1);
  833.     SSLVerifyConn=NULL;
  835.     return TRUE;
  836.     }
  838. module ssl_module =
  839.     {
  840.     STANDARD_MODULE_STUFF,
  841.     InitSSLServer, /* initializer */
  842.     CreateSSLDirConfig, /* dir config creater */
  843.     MergeSSLDirConfig, /* dir merger --- default is to override */
  844.     CreateSSLServerConfig, /* server config */
  845.     NULL, /* merge server config */
  846.     ssl_cmds, /* command table */
  847.     NULL, /* handlers */
  848.     NULL, /* filename translation */
  849.     FakeBasicAuth, /* check_user_id */
  850.     NULL, /* check auth */
  851.     SSLCheckCipher, /* check access */
  852.     NULL, /* type_checker */
  853.     SSLFixups, /* fixups */
  854.     NULL, /* logger */
  855.     };