net/rxrpc/security.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* RxRPC security handling
   3  *
   4  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/net.h>
  10 #include <linux/skbuff.h>
  11 #include <linux/udp.h>
  12 #include <linux/crypto.h>
  13 #include <net/sock.h>
  14 #include <net/af_rxrpc.h>
  15 #include <keys/rxrpc-type.h>
  16 #include "ar-internal.h"
  17
  18 static const struct rxrpc_security *rxrpc_security_types[] = {
  19         [RXRPC_SECURITY_NONE]   = &rxrpc_no_security,
  20 #ifdef CONFIG_RXKAD
  21         [RXRPC_SECURITY_RXKAD]  = &rxkad,
  22 #endif
  23 };
  24
  25 int __init rxrpc_init_security(void)
  26 {
  27         int i, ret;
  28
  29         for (i = 0; i < ARRAY_SIZE(rxrpc_security_types); i++) {
  30                 if (rxrpc_security_types[i]) {
  31                         ret = rxrpc_security_types[i]->init();
  32                         if (ret < 0)
  33                                 goto failed;
  34                 }
  35         }
  36
  37         return 0;
  38
  39 failed:
  40         for (i--; i >= 0; i--)
  41                 if (rxrpc_security_types[i])
  42                         rxrpc_security_types[i]->exit();
  43         return ret;
  44 }
  45
  46 void rxrpc_exit_security(void)
  47 {
  48         int i;
  49
  50         for (i = 0; i < ARRAY_SIZE(rxrpc_security_types); i++)
  51                 if (rxrpc_security_types[i])
  52                         rxrpc_security_types[i]->exit();
  53 }
  54
  55 /*
  56  * look up an rxrpc security module
  57  */
  58 const struct rxrpc_security *rxrpc_security_lookup(u8 security_index)
  59 {
  60         if (security_index >= ARRAY_SIZE(rxrpc_security_types))
  61                 return NULL;
  62         return rxrpc_security_types[security_index];
  63 }
  64
  65 /*
  66  * Initialise the security on a client call.
  67  */
  68 int rxrpc_init_client_call_security(struct rxrpc_call *call)
  69 {
  70         const struct rxrpc_security *sec = &rxrpc_no_security;
  71         struct rxrpc_key_token *token;
  72         struct key *key = call->key;
  73         int ret;
  74
  75         if (!key)
  76                 goto found;
  77
  78         ret = key_validate(key);
  79         if (ret < 0)
  80                 return ret;
  81
  82         for (token = key->payload.data[0]; token; token = token->next) {
  83                 sec = rxrpc_security_lookup(token->security_index);
  84                 if (sec)
  85                         goto found;
  86         }
  87         return -EKEYREJECTED;
  88
  89 found:
  90         call->security = sec;
  91         call->security_ix = sec->security_index;
  92         return 0;
  93 }
  94
  95 /*
  96  * initialise the security on a client connection
  97  */
  98 int rxrpc_init_client_conn_security(struct rxrpc_connection *conn)
  99 {
 100         const struct rxrpc_security *sec;
 101         struct rxrpc_key_token *token;
 102         struct key *key = conn->key;
 103         int ret;
 104
 105         _enter("{%d},{%x}", conn->debug_id, key_serial(key));
 106
 107         if (!key)
 108                 return 0;
 109
 110         ret = key_validate(key);
 111         if (ret < 0)
 112                 return ret;
 113
 114         for (token = key->payload.data[0]; token; token = token->next) {
 115                 sec = rxrpc_security_lookup(token->security_index);
 116                 if (sec)
 117                         goto found;
 118         }
 119         return -EKEYREJECTED;
 120
 121 found:
 122         conn->security = sec;
 123
 124         ret = conn->security->init_connection_security(conn, token);
 125         if (ret < 0) {
 126                 conn->security = &rxrpc_no_security;
 127                 return ret;
 128         }
 129
 130         _leave(" = 0");
 131         return 0;
 132 }
 133
 134 /*
 135  * Set the ops a server connection.
 136  */
 137 const struct rxrpc_security *rxrpc_get_incoming_security(struct rxrpc_sock *rx,
 138                                                          struct sk_buff *skb)
 139 {
 140         const struct rxrpc_security *sec;
 141         struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 142
 143         _enter("");
 144
 145         sec = rxrpc_security_lookup(sp->hdr.securityIndex);
 146         if (!sec) {
 147                 rxrpc_direct_abort(skb, rxrpc_abort_unsupported_security,
 148                                    RX_INVALID_OPERATION, -EKEYREJECTED);
 149                 return NULL;
 150         }
 151
 152         if (sp->hdr.securityIndex != RXRPC_SECURITY_NONE &&
 153             !rx->securities) {
 154                 rxrpc_direct_abort(skb, rxrpc_abort_no_service_key,
 155                                    sec->no_key_abort, -EKEYREJECTED);
 156                 return NULL;
 157         }
 158
 159         return sec;
 160 }
 161
 162 /*
 163  * Find the security key for a server connection.
 164  */
 165 struct key *rxrpc_look_up_server_security(struct rxrpc_connection *conn,
 166                                           struct sk_buff *skb,
 167                                           u32 kvno, u32 enctype)
 168 {
 169         struct rxrpc_skb_priv *sp = rxrpc_skb(skb);
 170         struct rxrpc_sock *rx;
 171         struct key *key = ERR_PTR(-EKEYREJECTED);
 172         key_ref_t kref = NULL;
 173         char kdesc[5 + 1 + 3 + 1 + 12 + 1 + 12 + 1];
 174         int ret;
 175
 176         _enter("");
 177
 178         if (enctype)
 179                 sprintf(kdesc, "%u:%u:%u:%u",
 180                         sp->hdr.serviceId, sp->hdr.securityIndex, kvno, enctype);
 181         else if (kvno)
 182                 sprintf(kdesc, "%u:%u:%u",
 183                         sp->hdr.serviceId, sp->hdr.securityIndex, kvno);
 184         else
 185                 sprintf(kdesc, "%u:%u",
 186                         sp->hdr.serviceId, sp->hdr.securityIndex);
 187
 188         rcu_read_lock();
 189
 190         rx = rcu_dereference(conn->local->service);
 191         if (!rx)
 192                 goto out;
 193
 194         /* look through the service's keyring */
 195         kref = keyring_search(make_key_ref(rx->securities, 1UL),
 196                               &key_type_rxrpc_s, kdesc, true);
 197         if (IS_ERR(kref)) {
 198                 key = ERR_CAST(kref);
 199                 goto out;
 200         }
 201
 202         key = key_ref_to_ptr(kref);
 203
 204         ret = key_validate(key);
 205         if (ret < 0) {
 206                 key_put(key);
 207                 key = ERR_PTR(ret);
 208                 goto out;
 209         }
 210
 211 out:
 212         rcu_read_unlock();
 213         return key;
 214 }