[SCTP]: API updates to suport SCTP-AUTH extensions.

Add SCTP-AUTH API.  The API implemented here was
agreed to between implementors at the 9th SCTP Interop.
It will be documented in the next revision of the
SCTP socket API spec.

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

1 files changed, 304 insertions, 0 deletions

diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 7738915011a0..f3e1a9c811ad 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -2946,6 +2946,164 @@ static int sctp_setsockopt_maxburst(struct sock *sk,
         return 0;
 }
 
+/*
+ * 7.1.18.  Add a chunk that must be authenticated (SCTP_AUTH_CHUNK)
+ *
+ * This set option adds a chunk type that the user is requesting to be
+ * received only in an authenticated way.  Changes to the list of chunks
+ * will only effect future associations on the socket.
+ */
+static int sctp_setsockopt_auth_chunk(struct sock *sk,
+                                    char __user *optval,
+                                    int optlen)
+{
+        struct sctp_authchunk val;
+
+        if (optlen != sizeof(struct sctp_authchunk))
+                return -EINVAL;
+        if (copy_from_user(&val, optval, optlen))
+                return -EFAULT;
+
+        switch (val.sauth_chunk) {
+                case SCTP_CID_INIT:
+                case SCTP_CID_INIT_ACK:
+                case SCTP_CID_SHUTDOWN_COMPLETE:
+                case SCTP_CID_AUTH:
+                        return -EINVAL;
+        }
+
+        /* add this chunk id to the endpoint */
+        return sctp_auth_ep_add_chunkid(sctp_sk(sk)->ep, val.sauth_chunk);
+}
+
+/*
+ * 7.1.19.  Get or set the list of supported HMAC Identifiers (SCTP_HMAC_IDENT)
+ *
+ * This option gets or sets the list of HMAC algorithms that the local
+ * endpoint requires the peer to use.
+ */
+static int sctp_setsockopt_hmac_ident(struct sock *sk,
+                                    char __user *optval,
+                                    int optlen)
+{
+        struct sctp_hmacalgo *hmacs;
+        int err;
+
+        if (optlen < sizeof(struct sctp_hmacalgo))
+                return -EINVAL;
+
+        hmacs = kmalloc(optlen, GFP_KERNEL);
+        if (!hmacs)
+                return -ENOMEM;
+
+        if (copy_from_user(hmacs, optval, optlen)) {
+                err = -EFAULT;
+                goto out;
+        }
+
+        if (hmacs->shmac_num_idents == 0 ||
+            hmacs->shmac_num_idents > SCTP_AUTH_NUM_HMACS) {
+                err = -EINVAL;
+                goto out;
+        }
+
+        err = sctp_auth_ep_set_hmacs(sctp_sk(sk)->ep, hmacs);
+out:
+        kfree(hmacs);
+        return err;
+}
+
+/*
+ * 7.1.20.  Set a shared key (SCTP_AUTH_KEY)
+ *
+ * This option will set a shared secret key which is used to build an
+ * association shared key.
+ */
+static int sctp_setsockopt_auth_key(struct sock *sk,
+                                    char __user *optval,
+                                    int optlen)
+{
+        struct sctp_authkey *authkey;
+        struct sctp_association *asoc;
+        int ret;
+
+        if (optlen <= sizeof(struct sctp_authkey))
+                return -EINVAL;
+
+        authkey = kmalloc(optlen, GFP_KERNEL);
+        if (!authkey)
+                return -ENOMEM;
+
+        if (copy_from_user(authkey, optval, optlen)) {
+                ret = -EFAULT;
+                goto out;
+        }
+
+        asoc = sctp_id2assoc(sk, authkey->sca_assoc_id);
+        if (!asoc && authkey->sca_assoc_id && sctp_style(sk, UDP)) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ret = sctp_auth_set_key(sctp_sk(sk)->ep, asoc, authkey);
+out:
+        kfree(authkey);
+        return ret;
+}
+
+/*
+ * 7.1.21.  Get or set the active shared key (SCTP_AUTH_ACTIVE_KEY)
+ *
+ * This option will get or set the active shared key to be used to build
+ * the association shared key.
+ */
+static int sctp_setsockopt_active_key(struct sock *sk,
+                                        char __user *optval,
+                                        int optlen)
+{
+        struct sctp_authkeyid val;
+        struct sctp_association *asoc;
+
+        if (optlen != sizeof(struct sctp_authkeyid))
+                return -EINVAL;
+        if (copy_from_user(&val, optval, optlen))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, val.scact_assoc_id);
+        if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        return sctp_auth_set_active_key(sctp_sk(sk)->ep, asoc,
+                                        val.scact_keynumber);
+}
+
+/*
+ * 7.1.22.  Delete a shared key (SCTP_AUTH_DELETE_KEY)
+ *
+ * This set option will delete a shared secret key from use.
+ */
+static int sctp_setsockopt_del_key(struct sock *sk,
+                                        char __user *optval,
+                                        int optlen)
+{
+        struct sctp_authkeyid val;
+        struct sctp_association *asoc;
+
+        if (optlen != sizeof(struct sctp_authkeyid))
+                return -EINVAL;
+        if (copy_from_user(&val, optval, optlen))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, val.scact_assoc_id);
+        if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        return sctp_auth_del_key_id(sctp_sk(sk)->ep, asoc,
+                                    val.scact_keynumber);
+
+}
+
+
 /* API 6.2 setsockopt(), getsockopt()
  *
  * Applications use setsockopt() and getsockopt() to set or retrieve
@@ -3069,6 +3227,21 @@ SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,
         case SCTP_MAX_BURST:
                 retval = sctp_setsockopt_maxburst(sk, optval, optlen);
                 break;
+        case SCTP_AUTH_CHUNK:
+                retval = sctp_setsockopt_auth_chunk(sk, optval, optlen);
+                break;
+        case SCTP_HMAC_IDENT:
+                retval = sctp_setsockopt_hmac_ident(sk, optval, optlen);
+                break;
+        case SCTP_AUTH_KEY:
+                retval = sctp_setsockopt_auth_key(sk, optval, optlen);
+                break;
+        case SCTP_AUTH_ACTIVE_KEY:
+                retval = sctp_setsockopt_active_key(sk, optval, optlen);
+                break;
+        case SCTP_AUTH_DELETE_KEY:
+                retval = sctp_setsockopt_del_key(sk, optval, optlen);
+                break;
         default:
                 retval = -ENOPROTOOPT;
                 break;
@@ -4840,6 +5013,118 @@ static int sctp_getsockopt_maxburst(struct sock *sk, int len,
         return -ENOTSUPP;
 }
 
+static int sctp_getsockopt_hmac_ident(struct sock *sk, int len,
+                                    char __user *optval, int __user *optlen)
+{
+        struct sctp_hmac_algo_param *hmacs;
+        __u16 param_len;
+
+        hmacs = sctp_sk(sk)->ep->auth_hmacs_list;
+        param_len = ntohs(hmacs->param_hdr.length);
+
+        if (len < param_len)
+                return -EINVAL;
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(optval, hmacs->hmac_ids, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+static int sctp_getsockopt_active_key(struct sock *sk, int len,
+                                    char __user *optval, int __user *optlen)
+{
+        struct sctp_authkeyid val;
+        struct sctp_association *asoc;
+
+        if (len < sizeof(struct sctp_authkeyid))
+                return -EINVAL;
+        if (copy_from_user(&val, optval, sizeof(struct sctp_authkeyid)))
+                return -EFAULT;
+
+        asoc = sctp_id2assoc(sk, val.scact_assoc_id);
+        if (!asoc && val.scact_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        if (asoc)
+                val.scact_keynumber = asoc->active_key_id;
+        else
+                val.scact_keynumber = sctp_sk(sk)->ep->active_key_id;
+
+        return 0;
+}
+
+static int sctp_getsockopt_peer_auth_chunks(struct sock *sk, int len,
+                                    char __user *optval, int __user *optlen)
+{
+        struct sctp_authchunks val;
+        struct sctp_association *asoc;
+        struct sctp_chunks_param *ch;
+        char __user *to;
+
+        if (len <= sizeof(struct sctp_authchunks))
+                return -EINVAL;
+
+        if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks)))
+                return -EFAULT;
+
+        to = val.gauth_chunks;
+        asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
+        if (!asoc)
+                return -EINVAL;
+
+        ch = asoc->peer.peer_chunks;
+
+        /* See if the user provided enough room for all the data */
+        if (len < ntohs(ch->param_hdr.length))
+                return -EINVAL;
+
+        len = ntohs(ch->param_hdr.length);
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(to, ch->chunks, len))
+                return -EFAULT;
+
+        return 0;
+}
+
+static int sctp_getsockopt_local_auth_chunks(struct sock *sk, int len,
+                                    char __user *optval, int __user *optlen)
+{
+        struct sctp_authchunks val;
+        struct sctp_association *asoc;
+        struct sctp_chunks_param *ch;
+        char __user *to;
+
+        if (len <= sizeof(struct sctp_authchunks))
+                return -EINVAL;
+
+        if (copy_from_user(&val, optval, sizeof(struct sctp_authchunks)))
+                return -EFAULT;
+
+        to = val.gauth_chunks;
+        asoc = sctp_id2assoc(sk, val.gauth_assoc_id);
+        if (!asoc && val.gauth_assoc_id && sctp_style(sk, UDP))
+                return -EINVAL;
+
+        if (asoc)
+                ch = (struct sctp_chunks_param*)asoc->c.auth_chunks;
+        else
+                ch = sctp_sk(sk)->ep->auth_chunk_list;
+
+        if (len < ntohs(ch->param_hdr.length))
+                return -EINVAL;
+
+        len = ntohs(ch->param_hdr.length);
+        if (put_user(len, optlen))
+                return -EFAULT;
+        if (copy_to_user(to, ch->chunks, len))
+                return -EFAULT;
+
+        return 0;
+}
+
 SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
                                 char __user *optval, int __user *optlen)
 {
@@ -4963,6 +5248,25 @@ SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
         case SCTP_MAX_BURST:
                 retval = sctp_getsockopt_maxburst(sk, len, optval, optlen);
                 break;
+        case SCTP_AUTH_KEY:
+        case SCTP_AUTH_CHUNK:
+        case SCTP_AUTH_DELETE_KEY:
+                retval = -EOPNOTSUPP;
+                break;
+        case SCTP_HMAC_IDENT:
+                retval = sctp_getsockopt_hmac_ident(sk, len, optval, optlen);
+                break;
+        case SCTP_AUTH_ACTIVE_KEY:
+                retval = sctp_getsockopt_active_key(sk, len, optval, optlen);
+                break;
+        case SCTP_PEER_AUTH_CHUNKS:
+                retval = sctp_getsockopt_peer_auth_chunks(sk, len, optval,
+                                                        optlen);
+                break;
+        case SCTP_LOCAL_AUTH_CHUNKS:
+                retval = sctp_getsockopt_local_auth_chunks(sk, len, optval,
+                                                        optlen);
+                break;
         default:
                 retval = -ENOPROTOOPT;
                 break;