[SCTP]: Implement SCTP-AUTH initializations.

The patch initializes AUTH related members of the generic SCTP
structures and provides a way to enable/disable auth extension.

Signed-off-by: Vlad Yasevich <vladislav.yasevich@hp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 83 insertions, 0 deletions

diff --git a/net/sctp/endpointola.c b/net/sctp/endpointola.c
index 22371185efb6..c8d5023606a5 100644
--- a/net/sctp/endpointola.c
+++ b/net/sctp/endpointola.c
@@ -69,12 +69,56 @@ static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep,
                                                 struct sock *sk,
                                                 gfp_t gfp)
 {
+        struct sctp_hmac_algo_param *auth_hmacs = NULL;
+        struct sctp_chunks_param *auth_chunks = NULL;
+        struct sctp_shared_key *null_key;
+        int err;
+
         memset(ep, 0, sizeof(struct sctp_endpoint));
 
         ep->digest = kzalloc(SCTP_SIGNATURE_SIZE, gfp);
         if (!ep->digest)
                 return NULL;
 
+        if (sctp_auth_enable) {
+                /* Allocate space for HMACS and CHUNKS authentication
+                 * variables.  There are arrays that we encode directly
+                 * into parameters to make the rest of the operations easier.
+                 */
+                auth_hmacs = kzalloc(sizeof(sctp_hmac_algo_param_t) +
+                                sizeof(__u16) * SCTP_AUTH_NUM_HMACS, gfp);
+                if (!auth_hmacs)
+                        goto nomem;
+
+                auth_chunks = kzalloc(sizeof(sctp_chunks_param_t) +
+                                        SCTP_NUM_CHUNK_TYPES, gfp);
+                if (!auth_chunks)
+                        goto nomem;
+
+                /* Initialize the HMACS parameter.
+                 * SCTP-AUTH: Section 3.3
+                 *    Every endpoint supporting SCTP chunk authentication MUST
+                 *    support the HMAC based on the SHA-1 algorithm.
+                 */
+                auth_hmacs->param_hdr.type = SCTP_PARAM_HMAC_ALGO;
+                auth_hmacs->param_hdr.length =
+                                        htons(sizeof(sctp_paramhdr_t) + 2);
+                auth_hmacs->hmac_ids[0] = htons(SCTP_AUTH_HMAC_ID_SHA1);
+
+                /* Initialize the CHUNKS parameter */
+                auth_chunks->param_hdr.type = SCTP_PARAM_CHUNKS;
+
+                /* If the Add-IP functionality is enabled, we must
+                 * authenticate, ASCONF and ASCONF-ACK chunks
+                 */
+                if (sctp_addip_enable) {
+                        auth_chunks->chunks[0] = SCTP_CID_ASCONF;
+                        auth_chunks->chunks[1] = SCTP_CID_ASCONF_ACK;
+                        auth_chunks->param_hdr.length =
+                                        htons(sizeof(sctp_paramhdr_t) + 2);
+                }
+        }
+
         /* Initialize the base structure. */
         /* What type of endpoint are we?  */
         ep->base.type = SCTP_EP_TYPE_SOCKET;
@@ -114,7 +158,36 @@ static struct sctp_endpoint *sctp_endpoint_init(struct sctp_endpoint *ep,
         ep->last_key = ep->current_key = 0;
         ep->key_changed_at = jiffies;
 
+        /* SCTP-AUTH extensions*/
+        INIT_LIST_HEAD(&ep->endpoint_shared_keys);
+        null_key = sctp_auth_shkey_create(0, GFP_KERNEL);
+        if (!null_key)
+                goto nomem;
+
+        list_add(&null_key->key_list, &ep->endpoint_shared_keys);
+
+        /* Allocate and initialize transorms arrays for suported HMACs. */
+        err = sctp_auth_init_hmacs(ep, gfp);
+        if (err)
+                goto nomem_hmacs;
+
+        /* Add the null key to the endpoint shared keys list and
+         * set the hmcas and chunks pointers.
+         */
+        ep->auth_hmacs_list = auth_hmacs;
+        ep->auth_chunk_list = auth_chunks;
+
         return ep;
+
+nomem_hmacs:
+        sctp_auth_destroy_keys(&ep->endpoint_shared_keys);
+nomem:
+        /* Free all allocations */
+        kfree(auth_hmacs);
+        kfree(auth_chunks);
+        kfree(ep->digest);
+        return NULL;
+
 }
 
 /* Create a sctp_endpoint with all that boring stuff initialized.
@@ -187,6 +260,16 @@ static void sctp_endpoint_destroy(struct sctp_endpoint *ep)
         /* Free the digest buffer */
         kfree(ep->digest);
 
+        /* SCTP-AUTH: Free up AUTH releated data such as shared keys
+         * chunks and hmacs arrays that were allocated
+         */
+        sctp_auth_destroy_keys(&ep->endpoint_shared_keys);
+        kfree(ep->auth_hmacs_list);
+        kfree(ep->auth_chunk_list);
+
+        /* AUTH - Free any allocated HMAC transform containers */
+        sctp_auth_destroy_hmacs(ep->auth_hmacs);
+
         /* Cleanup. */
         sctp_inq_free(&ep->base.inqueue);
         sctp_bind_addr_free(&ep->base.bind_addr);