#include <stdio.h>
#include <string.h>
+#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#endif
#if HAVE_GNUTLS_H
+#include <gnutls/x509.h>
+#include <gnutls/gnutls.h>
+#define ENABLE_SSL 2
+
+#if ENABLE_SSL == 1
#include <gnutls/openssl.h>
-#define ENABLE_SSL 1
+#endif
+
#endif
#if HAVE_OPENSSL_SSL_H
#define YAZ_SOCKLEN_T int
#endif
+#if ENABLE_SSL == 2
+struct tcpip_cred_ptr {
+ gnutls_certificate_credentials_t xcred;
+ int ref;
+};
+
+#endif
/* this state is used for both SSL and straight TCP/IP */
typedef struct tcpip_state
{
struct sockaddr_in addr; /* returned by cs_straddr */
#endif
char buf[128]; /* returned by cs_addrstr */
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ struct tcpip_cred_ptr *cred_ptr;
+ gnutls_session_t session;
+ char cert_fname[256];
+#elif ENABLE_SSL == 1
SSL_CTX *ctx; /* current CTX. */
SSL_CTX *ctx_alloc; /* If =ctx it is owned by CS. If 0 it is not owned */
SSL *ssl;
p->stackerr = 0;
p->user = 0;
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ sp->cred_ptr = 0;
+ sp->session = 0;
+ strcpy(sp->cert_fname, "yaz.pem");
+#elif ENABLE_SSL == 1
sp->ctx = sp->ctx_alloc = 0;
sp->ssl = 0;
strcpy(sp->cert_fname, "yaz.pem");
return p;
}
+#if ENABLE_SSL == 2
+static void tcpip_create_cred(COMSTACK cs)
+{
+ tcpip_state *sp = (tcpip_state *) cs->cprivate;
+ sp->cred_ptr = xmalloc(sizeof(*sp->cred_ptr));
+ sp->cred_ptr->ref = 1;
+ gnutls_certificate_allocate_credentials(&sp->cred_ptr->xcred);
+}
-#if ENABLE_SSL
+#endif
COMSTACK ssl_type(int s, int flags, int protocol, void *vp)
{
+#if !ENABLE_SSL
+ return 0;
+#else
tcpip_state *sp;
COMSTACK p;
p->type = ssl_type;
sp = (tcpip_state *) p->cprivate;
+#if ENABLE_SSL == 2
+ sp->session = (gnutls_session_t) vp;
+#else
sp->ctx = (SSL_CTX *) vp; /* may be NULL */
-
+#endif
/* note: we don't handle already opened socket in SSL mode - yet */
return p;
+#endif
}
-int ssl_check_error(COMSTACK h, tcpip_state *sp, int res)
+#if ENABLE_SSL
+static int ssl_check_error(COMSTACK h, tcpip_state *sp, int res)
{
#if HAVE_OPENSSL_SSL_H
int err = SSL_get_error(sp->ssl, res);
return 1;
}
#else
+#if ENABLE_SSL == 2
+ TRC(fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
+ res,
+ gnutls_error_is_fatal(res),
+ gnutls_strerror(res)));
+ if (res == GNUTLS_E_AGAIN || res == GNUTLS_E_INTERRUPTED)
+ {
+ int dir = gnutls_record_get_direction(sp->session);
+ TRC(fprintf(stderr, " -> incomplete dir=%d\n", dir));
+ h->io_pending = dir ? CS_WANT_WRITE : CS_WANT_READ;
+ return 1;
+ }
+#else
int tls_error = sp->ssl->last_error;
TRC(fprintf(stderr, "ssl_check_error error=%d fatal=%d msg=%s\n",
sp->ssl->last_error,
return 1;
}
#endif
+#endif
h->cerrno = CSERRORSSL;
return 0;
}
h->cerrno = CSOUTSTATE;
return -1;
}
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ if (h->type == ssl_type && !sp->session)
+ {
+ int res;
+ gnutls_global_init();
+
+ tcpip_create_cred(h);
+
+ gnutls_init(&sp->session, GNUTLS_CLIENT);
+ gnutls_priority_set_direct(sp->session, "PERFORMANCE", NULL);
+ gnutls_credentials_set (sp->session, GNUTLS_CRD_CERTIFICATE,
+ sp->cred_ptr->xcred);
+
+ gnutls_transport_set_ptr(sp->session, (gnutls_transport_ptr_t) h->iofile);
+
+ res = gnutls_handshake(sp->session);
+ if (res < 0)
+ {
+ if (ssl_check_error(h, sp, res))
+ return 1;
+ return -1;
+ }
+ }
+#elif ENABLE_SSL == 1
if (h->type == ssl_type && !sp->ctx)
{
SSL_library_init();
}
#endif
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ if (h->type == ssl_type && !sp->session)
+ {
+ int res;
+ gnutls_global_init();
+
+ tcpip_create_cred(h);
+
+ res = gnutls_certificate_set_x509_key_file(sp->cred_ptr->xcred,
+ sp->cert_fname,
+ sp->cert_fname,
+ GNUTLS_X509_FMT_PEM);
+ if (res != GNUTLS_E_SUCCESS)
+ {
+ h->cerrno = CSERRORSSL;
+ return -1;
+ }
+ }
+#elif ENABLE_SSL == 1
if (h->type == ssl_type && !sp->ctx)
{
SSL_library_init();
COMSTACK tcpip_accept(COMSTACK h)
{
COMSTACK cnew;
- tcpip_state *state, *st = (tcpip_state *)h->cprivate;
#ifdef WIN32
unsigned long tru = 1;
#endif
- TRC(fprintf(stderr, "tcpip_accept\n"));
+ TRC(fprintf(stderr, "tcpip_accept h=%p pid=%d\n", h, getpid()));
if (h->state == CS_ST_INCON)
{
+ tcpip_state *state, *st = (tcpip_state *)h->cprivate;
if (!(cnew = (COMSTACK)xmalloc(sizeof(*cnew))))
{
h->cerrno = CSYSERR;
memcpy(cnew, h, sizeof(*h));
cnew->iofile = h->newfd;
cnew->io_pending = 0;
+
if (!(state = (tcpip_state *)
(cnew->cprivate = xmalloc(sizeof(tcpip_state)))))
{
cnew->state = CS_ST_ACCEPT;
h->state = CS_ST_IDLE;
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ state->cred_ptr = st->cred_ptr;
+ state->session = 0;
+ if (st->cred_ptr)
+ {
+ int res;
+
+ (state->cred_ptr->ref)++;
+ gnutls_init(&state->session, GNUTLS_SERVER);
+ if (!state->session)
+ {
+ xfree(cnew);
+ xfree(state);
+ return 0;
+ }
+ res = gnutls_priority_set_direct(state->session,
+ "PERFORMANCE", NULL);
+ if (res != GNUTLS_E_SUCCESS)
+ {
+ xfree(cnew);
+ xfree(state);
+ return 0;
+ }
+ res = gnutls_credentials_set(state->session,
+ GNUTLS_CRD_CERTIFICATE,
+ st->cred_ptr->xcred);
+ if (res != GNUTLS_E_SUCCESS)
+ {
+ xfree(cnew);
+ xfree(state);
+ return 0;
+ }
+ gnutls_transport_set_ptr(state->session,
+ (gnutls_transport_ptr_t) cnew->iofile);
+ }
+#elif ENABLE_SSL == 1
state->ctx = st->ctx;
state->ctx_alloc = 0;
state->ssl = st->ssl;
}
if (h->state == CS_ST_ACCEPT)
{
-
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ tcpip_state *state = (tcpip_state *)h->cprivate;
+ if (state->session)
+ {
+ int res = gnutls_handshake(state->session);
+ if (res < 0)
+ {
+ if (ssl_check_error(h, state, res))
+ {
+ TRC(fprintf(stderr, "gnutls_handshake int in tcpip_accept\n"));
+ return h;
+ }
+ TRC(fprintf(stderr, "gnutls_handshake failed in tcpip_accept\n"));
+ cs_close(h);
+ return 0;
+ }
+ TRC(fprintf(stderr, "SSL_accept complete. gnutls\n"));
+ }
+#elif ENABLE_SSL == 1
tcpip_state *state = (tcpip_state *)h->cprivate;
if (state->ctx)
{
else if (*bufsize - hasread < CS_TCPIP_BUFCHUNK)
if (!(*buf =(char *)xrealloc(*buf, *bufsize *= 2)))
return -1;
+#if ENABLE_SSL == 2
+ res = gnutls_record_recv(sp->session, *buf + hasread,
+ CS_TCPIP_BUFCHUNK);
+ if (res < 0)
+ {
+ if (ssl_check_error(h, sp, res))
+ break;
+ return -1;
+ }
+#else
res = SSL_read(sp->ssl, *buf + hasread, CS_TCPIP_BUFCHUNK);
TRC(fprintf(stderr, " SSL_read res=%d, hasread=%d\n", res, hasread));
if (res <= 0)
break;
return -1;
}
+#endif
hasread += res;
}
TRC (fprintf (stderr, " Out of read loop with hasread=%d, berlen=%d\n",
}
while (state->towrite > state->written)
{
+#if ENABLE_SSL == 2
+ res = gnutls_record_send(state->session, buf + state->written,
+ size - state->written);
+ if (res <= 0)
+ {
+ if (ssl_check_error(h, state, res))
+ return 1;
+ return -1;
+ }
+#elif ENABLE_SSL == 1
res = SSL_write(state->ssl, buf + state->written,
size - state->written);
if (res <= 0)
return 1;
return -1;
}
+#endif
state->written += res;
TRC(fprintf(stderr, " Wrote %d, written=%d, nbytes=%d\n",
res, state->written, size));
{
tcpip_state *sp = (struct tcpip_state *)h->cprivate;
- TRC(fprintf(stderr, "tcpip_close\n"));
+ TRC(fprintf(stderr, "tcpip_close h=%p pid=%d\n", h, getpid()));
if (h->iofile != -1)
{
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ if (sp->session)
+ gnutls_bye(sp->session, GNUTLS_SHUT_RDWR);
+#elif ENABLE_SSL == 2
if (sp->ssl)
{
SSL_shutdown(sp->ssl);
}
if (sp->altbuf)
xfree(sp->altbuf);
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ if (sp->session)
+ {
+ gnutls_deinit(sp->session);
+ }
+ if (sp->cred_ptr)
+ {
+ assert(sp->cred_ptr->ref > 0);
+
+ if (--(sp->cred_ptr->ref) == 0)
+ {
+ TRC(fprintf(stderr, "Removed credentials %p pid=%d\n",
+ sp->cred_ptr->xcred, getpid()));
+ gnutls_certificate_free_credentials(sp->cred_ptr->xcred);
+ xfree(sp->cred_ptr);
+ }
+ sp->cred_ptr = 0;
+ }
+#elif ENABLE_SSL == 1
if (sp->ssl)
{
TRC(fprintf(stderr, "SSL_free\n"));
sprintf(buf, "http:%s", r);
else
sprintf(buf, "tcp:%s", r);
-#if ENABLE_SSL
+#if ENABLE_SSL == 2
+ if (sp->session)
+ {
+ if (h->protocol == PROTO_HTTP)
+ sprintf(buf, "https:%s", r);
+ else
+ sprintf(buf, "ssl:%s", r);
+ }
+#elif ENABLE_SSL == 1
if (sp->ctx)
{
if (h->protocol == PROTO_HTTP)
return 1;
}
+void cs_print_session_info(COMSTACK cs)
+{
+#if HAVE_GNUTLS_H
+#if ENABLE_SSL == 2
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ if (sp->session)
+ {
+ if (gnutls_certificate_type_get(sp->session) != GNUTLS_CRT_X509)
+ return;
+ printf("X509 certificate\n");
+ }
+#else
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ SSL *ssl = (SSL *) sp->ssl;
+ if (ssl)
+ {
+ gnutls_session_t session = ssl->gnutls_state;
+ if (gnutls_certificate_type_get(session) != GNUTLS_CRT_X509)
+ return;
+ printf("X509 certificate\n");
+ }
+#endif
+#endif
+#if HAVE_OPENSSL_SSL_H
+ struct tcpip_state *sp = (struct tcpip_state *) cs->cprivate;
+ SSL *ssl = (SSL *) sp->ssl;
+ if (ssl)
+ {
+ X509 *server_cert = SSL_get_peer_certificate(ssl);
+
+ if (server_cert)
+ {
+ char *pem_buf;
+ int pem_len;
+ BIO *bio = BIO_new(BIO_s_mem());
+
+ /* get PEM buffer in memory */
+ PEM_write_bio_X509(bio, server_cert);
+ pem_len = BIO_get_mem_data(bio, &pem_buf);
+ fwrite(pem_buf, pem_len, 1, stdout);
+
+ /* print all info on screen .. */
+ X509_print_fp(stdout, server_cert);
+ BIO_free(bio);
+
+ X509_free(server_cert);
+ }
+ }
+#endif
+}
+
void *cs_get_ssl(COMSTACK cs)
{
#if HAVE_OPENSSL_SSL_H
if (!cs || cs->type != ssl_type)
return 0;
sp = (struct tcpip_state *) cs->cprivate;
+#if ENABLE_SSL == 1
if (sp->ctx_alloc)
return 0;
sp->ctx = (SSL_CTX *) ctx;
+#endif
return 1;
}
int cs_get_peer_certificate_x509(COMSTACK cs, char **buf, int *len)
{
+#if HAVE_OPENSSL_SSL_H
SSL *ssl = (SSL *) cs_get_ssl(cs);
if (ssl)
{
-#if HAVE_OPENSSL_SSL_H
X509 *server_cert = SSL_get_peer_certificate(ssl);
if (server_cert)
{
BIO_free(bio);
return 1;
}
-#endif
}
+#endif
return 0;
}
#else