ksslapi.c revision c28749e97052f09388969427adf7df641cdcdc22
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/sysmacros.h>
#include "ksslimpl.h"
#include "ksslproto.h"
#include "ksslapi.h"
/*
* The socket T_bind_req message is intercepted and re-routed here
* to see is there is SSL relevant job to do, based on the kssl config
* in the kssl_entry_tab.
* Looks up the kernel SSL proxy table, to find an entry that matches the
* same serveraddr, and has one of the following two criteria:
* 1. in_port is an ssl_port. This endpoint can be used later as a fallback
* to complete connections that cannot be handled by the SSL kernel proxy
* (typically non supported ciphersuite). The cookie for the calling client
* is saved with the kssl_entry to be retrieved for the fallback.
* The function returns KSSL_HAS_PROXY.
*
* 2. in_port is a proxy port for another ssl port. The ssl port is then
* substituted to the in_port in the bind_req TPI structure, so that
* the bind falls through to the SSL port. At the end of this operation,
* all the packets arriving to the SSL port will be delivered to an
* accepted endpoint child of this bound socket.
* The kssl_entry_t is returned in *ksslent, for later use by the
* lower modules' SSL hooks that handle the Handshake messages.
* The function returns KSSL_IS_PROXY.
*
* The function returns KSSL_NO_PROXY otherwise. We do not suppport
* IPv6 addresses.
*/
{
int i;
struct T_bind_req *tbr;
if (kssl_enabled == 0) {
return (KSSL_NO_PROXY);
}
ret = KSSL_NO_PROXY;
switch (tbr->ADDR_length) {
case sizeof (sin_t):
break;
case sizeof (sin6_t):
/* Future support of IPv6 goes here */
default:
/* Should ASSERT() here? */
return (ret);
}
for (i = 0; i < kssl_entry_tab_size; i++) {
continue;
/* This is an SSL port to fallback to */
/*
* Let's see first if there's at least
* an endpoint for a proxy server.
* If there's none, then we return as we have
* no proxy, so that the bind() to the
* transport layer goes through.
* The calling module will ask for this
* cookie if it wants to fall back to it,
* so add this one to the list of fallback
* clients.
*/
if (!kssl_enqueue((kssl_chain_t **)
break;
}
/*
* Now transform the T_BIND_REQ into
* a T_BIND_ACK.
*/
break;
}
/* This is a proxy port. */
/* Append this entry to the bind_req mblk */
BPRI_MED);
break;
sizeof (kssl_entry_t);
/* Add the caller's cookie to proxies list */
if (!kssl_enqueue((kssl_chain_t **)
break;
}
/*
* Make this look like the SSL port to the
* transport below
*/
ret = KSSL_IS_PROXY;
break;
}
}
}
return (ret);
}
/*
* Retrieved an endpoint "bound" to the SSL entry.
* Such endpoint has previously called kssl_check_proxy(), got itself
* linked to the kssl_entry's ke_fallback_head list.
* This routine returns the cookie from that SSL entry ke_fallback_head list.
*/
void *
{
return (NULL);
}
/*
* matches "item"
* The chain is simple-linked and NULL ended.
*/
/*
* This routine returns TRUE if the item was either successfully added to
* the chain, or is already there. It returns FALSE otherwise.
*/
static boolean_t
{
/* Lookup the existing entries to avoid duplicates */
return (B_TRUE);
}
}
return (B_FALSE);
}
return (B_TRUE);
}
static void
{
else
return;
}
}
}
/*
* Holds the kssl_entry
*/
void
{
}
/*
* Releases the kssl_entry
* If the caller passes a cookie, then it should be removed from both
* proxies and fallbacks chains.
*/
void
{
if (endpt_type == KSSL_IS_PROXY)
cookie);
if (endpt_type == KSSL_HAS_PROXY)
cookie);
}
}
/*
* Holds the kssl context
*/
void
{
}
/*
* Releases the kssl_context
*/
void
{
}
/*
* Packets are accumulated here, if there are packets already queued,
* or if the context is active.
* The context is active when an incoming record processing function
* is already executing on a different thread.
* Queued packets are handled either when an mblk arrived and completes
* a record, or, when the active context processor finishes the task at
* hand.
* The caller has to keep calling this routine in a loop until it returns
* B_FALSE in *more. The reason for this is SSL3: The protocol
* allows the client to send its first application_data message right
* after it had sent its Finished message, and not wait for the server
* ChangeCipherSpec and Finished. This overlap means we can't batch up
* a returned Handshake message to be sent on the wire
* with a decrypted application_data to be delivered to the application.
*/
{
int mplen;
}
goto sendnewalert;
}
/* Whomever is currently processing this connection will get to this */
if (ssl->activeinput) {
}
return (KSSL_CMD_NONE);
}
/*
* Fast path for complete incoming application_data records on an empty
* queue.
* This is by far the most frequently encountered case
*/
if ((content_type == content_application_data) &&
return (KSSL_CMD_DELIVER_PROXY);
}
}
}
/* Accumulate at least one record */
}
goto sendalert;
}
/* Not even a complete header yet. wait for the rest */
return (KSSL_CMD_NONE);
}
do {
/*
* application_data records are decrypted and
* MAC-verified by the stream head, and in the context
* a read()'ing thread. This avoids unfairly charging
* the cost of handling this record on the whole system,
* and prevents doing it while in the shared IP
* perimeter.
*/
goto sendnewalert;
}
} else {
/*
* If we're past the initial handshake, start letting
* the stream head process all records, in particular
* the close_notify.
* This is needed to avoid processing them out of
* sequence when previous application data packets are
*/
} else {
}
}
/* Priority to Alert messages */
goto sendalert;
}
/* Then handshake messages */
if (ssl->handshake_sendbuf) {
} else {
}
(!ssl->activeinput));
return (kssl_cmd);
}
(!ssl->activeinput));
}
/*
* Don't process any packet after an application_data.
* We could well receive the close_notify which should
* be handled separately.
*/
return (kssl_cmd);
}
/*
* The current record isn't done yet. Don't start the next one
*/
if (ssl->activeinput) {
return (kssl_cmd);
}
return (kssl_cmd);
}
return (KSSL_CMD_SEND);
}
/*
* Decrypt and verify the MAC of an incoming chain of application_data record.
* Each block has exactly one SSL record.
* This routine recycles its incoming mblk, and flags it as DBLK_COOKED
*/
{
int mac_sz;
more:
/*
* Fortunately copyb() preserves the offset,
* tail space and alignement so the copy is
* ready to be made an SSL record.
*/
return (NULL);
} else {
}
}
if (content_type != content_application_data) {
/* Remove this message */
/*
* If we had processed blocks that need to
* be delivered, then remember that error code
*/
if (kssl_cmd == KSSL_CMD_DELIVER_PROXY)
}
goto sendalert;
}
if (deliverit) {
}
continue;
}
if (spec->cipher_ctx != 0) {
cipher_data.cd_offset = 0;
if (CRYPTO_ERR(error)) {
#ifdef DEBUG
"crypto_decrypt_update failed: 0x%02X",
error);
#endif /* DEBUG */
goto makealert;
}
}
pad_sz++;
goto makealert;
}
}
if (mac_sz != 0) {
goto makealert;
}
if (ret != CRYPTO_SUCCESS ||
#ifdef DEBUG
"msg MAC mismatch");
#endif /* DEBUG */
goto makealert;
}
}
goto makealert;
}
}
return (kssl_cmd);
/* internal memory allocation failure. just return. */
#ifdef DEBUG
"alert message allocation failed");
#endif /* DEBUG */
if (mp) {
goto more;
}
return (KSSL_CMD_NONE);
}
} else {
}
if (mp) {
goto more;
}
return (kssl_cmd);
}
/*
* This is the routine that handles incoming SSL records.
* When called the first time, with a NULL context, this routine expects
* a ClientHello SSL Handshake packet and shall allocate a context
* of a new SSL connection.
* During the rest of the handshake packets, the routine adjusts the
* state of the context according to the record received.
* After the ChangeCipherSpec message is received, the routine first
* decrypts/authenticated the packet using the key materials in the
* connection's context.
* The return code tells the caller what to do with the returned packet.
*/
static kssl_cmd_t
{
int rhsz = SSL3_HDR_LEN;
int sz;
int mac_sz;
if (content_type == content_handshake_v2) {
/* V2 compatible ClientHello */
} else {
/* We don't support "pure" SSLv2 */
goto sendalert;
}
}
rhsz = 2;
} else {
}
if (spec->cipher_ctx != 0) {
if (CRYPTO_ERR(error)) {
#ifdef DEBUG
"kssl_handle_any_record: crypto_decrypt_update "
"failed: 0x%02X", error);
#endif /* DEBUG */
goto sendalert;
}
}
pad_sz++;
goto sendalert;
}
}
if (mac_sz != 0) {
goto sendalert;
}
if (ret != CRYPTO_SUCCESS ||
#ifdef DEBUG
"msg MAC mismatch");
#endif /* DEBUG */
goto sendalert;
}
}
switch (content_type) {
case content_handshake:
do {
if (error != 0 ||
/* ignore client renegotiation for now */
}
if (error != 0) {
goto error;
}
return (KSSL_CMD_QUEUED);
}
}
int msglenb =
msglenb < 3) {
msglenb++;
}
if (msglenb == 3) {
}
}
return (KSSL_CMD_NONE);
}
}
continue;
}
continue;
}
goto error;
}
}
return (KSSL_CMD_NONE);
} else {
return (KSSL_CMD_NONE);
}
arg));
return (KSSL_CMD_NOT_SUPPORTED);
}
return (KSSL_CMD_QUEUED);
} else {
return (KSSL_CMD_NONE);
}
case content_alert:
if (rec_sz != 2) {
goto sendalert;
} else {
ssl->kssl_entry);
}
goto error;
} else {
return (KSSL_CMD_NONE);
}
}
} else {
#ifdef DEBUG
"kssl_spec_init returned error "
"0x%02X", error);
#endif /* DEBUG */
goto error;
}
return (KSSL_CMD_NONE);
}
goto sendalert;
case content_application_data:
goto sendalert;
}
return (KSSL_CMD_DELIVER_PROXY);
case content_handshake_v2:
return (KSSL_CMD_NOT_SUPPORTED);
} else if (error != 0) {
goto error;
}
return (KSSL_CMD_SEND);
default:
break;
}
return (KSSL_CMD_NONE);
}
/*
* Initialize the context of an SSL connection, coming to the specified
* address.
* the ssl structure returned is held.
*/
{
return (KSSL_STS_ERR);
}
return (KSSL_STS_OK);
}
/*
* Builds SSL records out of the chain of mblks, and returns it.
* Taked a copy of the message before encypting it if it has another
* reference.
* In case of failure, NULL is returned, and the message will be
* freed by the caller.
* A NULL mp means a close_notify is requested.
*/
mblk_t *
{
do {
/*
* Fortunately copyb() preserves the offset,
* tail space and alignement so the copy is
* ready to be made an SSL record.
*/
return (NULL);
} else {
}
}
return (NULL);
return (retmp);
}
/*
* Builds a single SSL record
* In-line encryption of the record.
*/
static kssl_status_t
{
int len;
int reclen = 0;
int mac_sz;
int pad_sz = 0;
}
/* Do we need an internal_error Alert here? */
return (KSSL_STS_ERR);
}
return (KSSL_STS_OK);
}