Streamlined security for mobile and embedded devices
|
| RSA BSAFE Micro Edition Suite |
Streamlined security for mobile and embedded devices |
|
|
/* $Id: ssl_server.c,v 1.57 2005/04/11 12:28:12 hfrancis Exp $ */ /* * Copyright (C) 1999-2003 RSA Security Inc. All rights reserved. * * This work contains proprietary information of RSA Security. * Distribution is limited to authorized licensees of RSA * Security. Any unauthorized reproduction, distribution or * modification of this work is strictly prohibited. */ /* * A source of pseudo random numbers is required for various aspects of the * security protocol and components included in this product. Failure to * appropriately seed the Pseudo Random Number Generator (PRNG) will * seriously impact the security provided. Your application should provide this * random seed. * * The exact requirements for this seeding process may depend upon your * application and the environment for which your application is designed. * See RFC 1750 - Randomness Recommendations for Security. */ #include "r_prod.h" #include "server_defaults.h" /* Default values for server samples */ #include "builtin_cert_pkey.h" /* Built-in certificate and private key */ #include "debug_cb.h" /* BIO and SSL state dump callback */ #include "arguments.h" /* Program arguments processing */ /* Global BIO for output to standard error */ BIO *bio_err; static void print_connection_source(BIO *accept_bio,BIO *bio_out); int main(int argc, char *argv[]) { int ret = R_ERROR_FAILED; /* Function return value */ BIO *bio = NULL; BIO *bio_out = NULL; BIO *abio = NULL; int bytes_read; /* Number of bytes read from client */ int bytes_written = 0; /* The number of Bytes written to client */ int sock_fd; /* The socket file descriptor */ int ssl_err; /* SSL error identifier */ static char buf[SSL_SERVER_DATA_BUFFER_LEN]; /* Application I/O buffer */ char *port = SSL_SERVER_PORT_DEFAULT; /* Port to accept clients */ char *ciphers = NULL; /* Cipher list, NULL means default */ int debug = 0; /* Switch for extra debug output */ int state = 0; /* Print the SSL state */ int connections = SSL_SERVER_UNLIMITED_CONNECTIONS; /* Connection count */ int extra_args; /* Extra arguments from command line */ int arg; /* Argument counter */ SSL_METHOD *meth = NULL; /* Pointer to server SSL method */ SSL *ssl = NULL; /* SSL connection object */ SSL_CTX *ssl_ctx = NULL; /* Pointer to SSL context */ R_LIB_CTX *lib_ctx = NULL; /* Pointer to library context */ SSLCERT *server_cert = NULL; /* Pointer to server certificate */ EVP_PKEY *pkey = NULL; /* Pointer to server private key */ int off = 0; /* Additional options */ static unsigned char rand_seed[] = "A bad seed for software PRNG"; int mode = R_LIB_CTX_FIPS140_MODE; /* Library's default mode */ /* Create an output channel */ if ((bio_err = BIO_new_fp(stderr, BIO_NOCLOSE)) == NULL) { goto end; } BIO_set_flags(bio_err, BIO_FLAGS_FLUSH_ON_WRITE); /* Create an output channel */ if ((bio_out = BIO_new_fp(stdout, BIO_NOCLOSE)) == NULL) { goto end; } BIO_set_flags(bio_out, BIO_FLAGS_FLUSH_ON_WRITE); /* Parse server arguments */ if (server_parse_arguments(argc, argv, bio_err, bio_out, &port, &connections, &debug, &state, &meth, &extra_args, &off, &ciphers, &mode)) { server_usage(bio_err, argv[0]); goto end; } /* If there are extra unparsed arguments then print usage and exit */ if (extra_args > 0) { /* Report the first command line problem */ for (arg = 1; arg < argc; arg++) { if (argv[arg] != NULL) { BIO_printf(bio_err, "\nUnknown argument : %s\n", argv[arg]); break; } } /* Report program usage and exit */ server_usage(bio_err, argv[0]); goto end; } /* Initialize the SSL library using the default resources */ if (PRODUCT_LIBRARY_NEW(PRODUCT_DEFAULT_RESOURCE_LIST(), R_RES_FLAG_DEF, &lib_ctx) != R_ERROR_NONE) { BIO_printf(bio_err, "Unable to create library context\n"); goto end; } /* * This demonstrates how to seed the software PRNG of the SSL library. * Seeding information gathered using software methods is not the best * source, so do not use the following example of application-specified * entropy in production. RNG hardware is considered the best source of * random information. */ if (R_rand_seed(R_rand_get_default(), rand_seed, sizeof(rand_seed)) == 0) { BIO_printf(bio_err, "Unable to seed the PRNG\n"); goto end; } #ifndef SSLC_SMALL_CODE SSL_load_error_strings(); #endif /* !SSLC_SMALL_CODE */ /* Set the server default method if it is not set */ if (meth == NULL) { /* * Select the protocol version in the following order: * - Use pure TLSv1 if it is the only protocol version available * - Use SSLv3 support optionally in an SSLv2 handshake * (for maximum compatibility) (if possible) * - Use pure SSLv3 * - Use pure SSLv2 */ #if defined(NO_SSL2) && defined(NO_SSL3) && !defined(NO_TLS1) meth = TLSv1_server_method(); BIO_printf(bio_out, "Doing TLSv1_server_method\n"); #elif (!defined(NO_SSL2) || defined(NO_SSL2IMPL)) && !defined(NO_SSL3) meth = SSLv23_server_method(); BIO_printf(bio_out, "Doing SSLv23_server_method\n"); #elif !defined(NO_SSL3) meth = SSLv3_server_method(); BIO_printf(bio_out, "Doing SSLv3_server_method\n"); #elif !defined(NO_SSL2) meth = SSLv2_server_method(); BIO_printf(bio_out, "Doing SSLv2_server_method\n"); #else BIO_printf(bio_err, "Unable to set default server method.\n"); goto end; #endif } /* Create an SSL context structure */ if ((ssl_ctx = SSL_CTX_new(meth)) == NULL) { BIO_printf(bio_err, "Unable to create SSL context\n"); goto end; } /* * Set the mode of operation of the context. * * Note this is only applicable to libraries that support FIPS/non-FIPS * modes of operations. */ (void)SSL_CTX_set_R_LIB_CTX(ssl_ctx, lib_ctx, mode); #ifndef SSLC_SMALL_CODE /* * Set the server temporary key generation mode. The temporary key * will be generated during the handshake. */ if (!SSL_CTX_set_tmp_key_mode(ssl_ctx, SSL_TMP_512_DH|SSL_TMP_1024_DH| SSL_TMP_512_RSA, SSL_TMP_GENERATE_LATER)) { BIO_printf(bio_err, "Unable to set temporary key mode\n"); goto end; } #endif /* !SSLC_SMALL_CODE */ /* Set the cipher list if specified. Otherwise use the default. */ if (ciphers != NULL) { SSL_CTX_set_cipher_list(ssl_ctx, ciphers); } /* Set the SSL information callback to print the SSL state */ if (state) { SSL_CTX_set_info_cb(ssl_ctx, ssl_state_info_cb); } /* Enable all vendor bug compatibility options */ SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL | off); /* Load the built in server certificate */ BIO_printf(bio_out, "Server is using the builtin certificate\n"); server_cert = sslcert_get_certificate(); if (!SSL_CTX_use_certificate(ssl_ctx, server_cert)) { BIO_printf(bio_err, "Unable to load server certificate\n"); goto end; } /* Load the built-in server private key */ BIO_printf(bio_out, "Server is using the builtin RSA key\n"); pkey = get_rsa512_priv_server(); if (!SSL_CTX_use_PrivateKey(ssl_ctx, pkey)) { BIO_printf(bio_err, "Unable to load server private key\n"); goto end; } /* * Check that the certificate and private key match. This is a common error * which should be avoided before starting the server, as without a * certificate and matching private key the SSL handshake cannot be * completed. */ if (!SSL_CTX_check_private_key(ssl_ctx)) { BIO_printf(bio_err, "Private key check failed\n"); goto end; } /* Set up an accept BIO to simplify the process of setting up a server */ if ((abio = BIO_new_accept(port)) == NULL) { BIO_printf(bio_err, "Unable to create accept BIO\n"); goto end; } /* Allow for easy restart of the server accept socket */ BIO_set_bind_mode(abio, SIO_BIND_REUSEADDR); /* * The first call to BIO_do_accept() sets up the socket for accepting * incoming connections by establishing a listener. */ if (BIO_do_accept(abio) <= 0) { BIO_printf(bio_err, "Unable to initialize server socket\n"); goto end; } /* * In debug mode add a BIO callback to output all data passing through the * connection. This can be done on the accept socket because the callback * reference is passed on to the accepting socket. */ if (debug) { BIO_set_cb(abio, bio_dump_cb); BIO_set_cb_arg(abio, (char *)bio_out); } /* * Create the SSL structure. Defaults are inherited from the SSL_CTX. * Options are usually set against the SSL_CTX with those requiring * modification set against the SSL. */ if ((ssl = SSL_new(ssl_ctx)) == NULL) { BIO_printf(bio_err, "Unable to create SSL structure\n"); goto end; } /* Enable anytime shutdown to handle https requests properly */ SSL_set_options(ssl, SSL_OP_ANYTIME_SHUTDOWN); /* * Enter the web server loop which will allow a set number of * connections before exiting. The number of connections will be * unlimited if the connections number is negative. */ while (connections != 0) { /* Decrement the connection count */ connections--; BIO_printf(bio_out, "\nWaiting for new connection ...\n"); /* * Reset the SSL connection deals to be in an "initial" state * ready to begin another handshake. */ SSL_clear(ssl); /* Accept a new client socket connection */ if (BIO_do_accept(abio) < 0) { /* The accept of a new socket failed */ BIO_printf(bio_out, "Accept of client connection failed\n"); ERR_print_errors(bio_out); /* Attempt a new socket connection */ continue; } /* Pop the newly generated BIO from the listener BIO */ bio = BIO_pop(abio); /* Print feedback about the socket connection */ print_connection_source(bio, bio_out); /* * The BIO is taken by SSL_set_bio(). It is not necessary to free it as * the SSL clean up process will do so. */ SSL_set_bio(ssl, bio, bio); /* * Instruct the SSL layer to perform the server-side of the protocol * when SSL_do_handshake() is called. SSL_do_handshake() is implicitly * called by SSL_read()/SSL_write(). Note that SSL_connect() or * SL_accept() explicitly do the client- or server-side handshake * functions. */ SSL_set_accept_state(ssl); /* * As this is performing non-blocking reads, call SSL_read(). This call * performs the full handshake. Read less than a full buffer here to * allow for processing later. */ bytes_read = SSL_read(ssl, buf, SSL_SERVER_DATA_BUFFER_LEN - 1); /* * Categorize the return value from the SSL call to determine how to * deal with the error. This call also works when the SSL return code * does not indicate an error in which case SSL_ERROR_NONE is always * returned here. */ ssl_err = SSL_get_error(ssl, bytes_read); switch (ssl_err) { case SSL_ERROR_NONE: /* The handshake finished, so continue parsing the data */ break; case SSL_ERROR_SSL: /* A handshake error: report and exit */ BIO_printf(bio_out, "Handshake failure\n"); ERR_print_errors(bio_out); goto close_connection; case SSL_ERROR_ZERO_RETURN: break; case SSL_ERROR_WANT_READ: case SSL_ERROR_WANT_WRITE: case SSL_ERROR_WANT_CONNECT: case SSL_ERROR_SYSCALL: default: /* * A system call error. This error is different from the * SSL_ERROR_SSL in that errno (under unix) has the numeric * error value, and is not converted into text. If performing an * SSL_read()/SSL_write() there is no recorded error in the error * logging because the error could be able to be retried which * the library is not aware of. */ BIO_printf(bio_out, "System call error (ssl_err=%d,ret=%d,errno=%d)\n", ssl_err, bytes_read, R_os_get_last_sys_error()); ERR_print_errors(bio_out); goto close_connection; break; } /* Process the data read from the client */ /* * NULL-terminate the buffer of data read from the client. The * assumption here is that the server has just read text data. */ buf[bytes_read] = '\0'; /* Report feedback to the standard output */ BIO_printf(bio_out, "Request received\n%s\n", buf); /* Write the prepared response to the client */ bytes_written = SSL_write(ssl, SSL_SERVER_RESPONSE_DEFAULT, Strlen(SSL_SERVER_RESPONSE_DEFAULT)); close_connection: /* Close the SSL connection */ SSL_shutdown(ssl); BIO_get_fd(bio, &sock_fd); shutdown(sock_fd, 2); /* * An error on the blocking socket will close the server. Ensure this * check after the socket for the SSL has been closed. */ if (bytes_written < 0) { BIO_printf(bio_err, "Server write response failed\n"); goto end; } /* Report the connection close to standard output */ BIO_printf(bio_out, "Done\n"); } /* Set program success */ ret = R_ERROR_NONE; end: /* On error output the error stack */ if ((ret != R_ERROR_NONE) && (bio_err != NULL)) { ERR_print_errors(bio_err); } /* Free memory for all structures */ if (ssl != NULL) { SSL_free(ssl); } /* Free the BIOs for standard out and error */ if (bio_out != NULL) { BIO_free(bio_out); } /* * The private key and certificate were generated as structures in memory * before being associated with the SSL. The application therefore still * has a reference to the private key and certificate which must be freed * now. */ if (pkey != NULL) { SSLCERT_PKEY_free(pkey); } if (server_cert != NULL) { SSLCERT_free(server_cert); } if (ssl_ctx != NULL) { /* * Do not check for the return as no more memory freeing will be * performed. */ SSL_CTX_free(ssl_ctx); } /* Free the SSL library context */ if (lib_ctx != NULL) { PRODUCT_LIBRARY_FREE(lib_ctx); } /* Free the accept BIO */ if (abio != NULL) { BIO_free(abio); } if (bio_err != NULL) { BIO_free(bio_err); bio_err = NULL; } return(R_ERROR_EXIT_CODE(ret)); } static void print_connection_source(BIO *accept_bio, BIO *bio_out) { int sock; /* Socket file descriptor */ unsigned long len; /* Length of socket data structure */ struct sockaddr_in name; /* Socket data structure */ static char hostbuf[128]; /* Buffer for the host name string */ int hostlen = 0; /* Length of the hostname string */ int i; /* Extract the file descriptor from the BIO */ BIO_get_fd(accept_bio, &sock); /* Make a socket call to get the socket address details */ len = sizeof(name); i = SIO_getsockname(sock, (struct sockaddr *) &name, &len); /* Get the peer host name from the address */ if (i == 0) { /* Initialize the hostname string to be empty */ hostbuf[0] = '\0'; hostlen = SIO_gethostbyaddr((unsigned char *)&name, (int)len, hostbuf, sizeof(hostbuf)); } else { BIO_printf(bio_out, "getsockname failed - %d\n", R_os_get_last_sys_error()); } /* Report the host name if it was found */ if (hostlen != 0) { BIO_printf(bio_out, "New connection from %s\n", hostbuf); } else { BIO_printf(bio_out, "New connection\n"); } return; }