1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2018 Oracle and/or its affiliates. All rights reserved. */ 3 4 #include <crypto/aead.h> 5 #include <linux/debugfs.h> 6 #include <net/xfrm.h> 7 8 #include "netdevsim.h" 9 10 #define NSIM_IPSEC_AUTH_BITS 128 11 12 static ssize_t nsim_dbg_netdev_ops_read(struct file *filp, 13 char __user *buffer, 14 size_t count, loff_t *ppos) 15 { 16 struct netdevsim *ns = filp->private_data; 17 struct nsim_ipsec *ipsec = &ns->ipsec; 18 size_t bufsize; 19 char *buf, *p; 20 int len; 21 int i; 22 23 /* the buffer needed is 24 * (num SAs * 3 lines each * ~60 bytes per line) + one more line 25 */ 26 bufsize = (ipsec->count * 4 * 60) + 60; 27 buf = kzalloc(bufsize, GFP_KERNEL); 28 if (!buf) 29 return -ENOMEM; 30 31 p = buf; 32 p += snprintf(p, bufsize - (p - buf), 33 "SA count=%u tx=%u\n", 34 ipsec->count, ipsec->tx); 35 36 for (i = 0; i < NSIM_IPSEC_MAX_SA_COUNT; i++) { 37 struct nsim_sa *sap = &ipsec->sa[i]; 38 39 if (!sap->used) 40 continue; 41 42 p += snprintf(p, bufsize - (p - buf), 43 "sa[%i] %cx ipaddr=0x%08x %08x %08x %08x\n", 44 i, (sap->rx ? 'r' : 't'), sap->ipaddr[0], 45 sap->ipaddr[1], sap->ipaddr[2], sap->ipaddr[3]); 46 p += snprintf(p, bufsize - (p - buf), 47 "sa[%i] spi=0x%08x proto=0x%x salt=0x%08x crypt=%d\n", 48 i, be32_to_cpu(sap->xs->id.spi), 49 sap->xs->id.proto, sap->salt, sap->crypt); 50 p += snprintf(p, bufsize - (p - buf), 51 "sa[%i] key=0x%08x %08x %08x %08x\n", 52 i, sap->key[0], sap->key[1], 53 sap->key[2], sap->key[3]); 54 } 55 56 len = simple_read_from_buffer(buffer, count, ppos, buf, p - buf); 57 58 kfree(buf); 59 return len; 60 } 61 62 static const struct file_operations ipsec_dbg_fops = { 63 .owner = THIS_MODULE, 64 .open = simple_open, 65 .read = nsim_dbg_netdev_ops_read, 66 }; 67 68 static int nsim_ipsec_find_empty_idx(struct nsim_ipsec *ipsec) 69 { 70 u32 i; 71 72 if (ipsec->count == NSIM_IPSEC_MAX_SA_COUNT) 73 return -ENOSPC; 74 75 /* search sa table */ 76 for (i = 0; i < NSIM_IPSEC_MAX_SA_COUNT; i++) { 77 if (!ipsec->sa[i].used) 78 return i; 79 } 80 81 return -ENOSPC; 82 } 83 84 static int nsim_ipsec_parse_proto_keys(struct xfrm_state *xs, 85 u32 *mykey, u32 *mysalt) 86 { 87 const char aes_gcm_name[] = "rfc4106(gcm(aes))"; 88 struct net_device *dev = xs->xso.dev; 89 unsigned char *key_data; 90 char *alg_name = NULL; 91 int key_len; 92 93 if (!xs->aead) { 94 netdev_err(dev, "Unsupported IPsec algorithm\n"); 95 return -EINVAL; 96 } 97 98 if (xs->aead->alg_icv_len != NSIM_IPSEC_AUTH_BITS) { 99 netdev_err(dev, "IPsec offload requires %d bit authentication\n", 100 NSIM_IPSEC_AUTH_BITS); 101 return -EINVAL; 102 } 103 104 key_data = &xs->aead->alg_key[0]; 105 key_len = xs->aead->alg_key_len; 106 alg_name = xs->aead->alg_name; 107 108 if (strcmp(alg_name, aes_gcm_name)) { 109 netdev_err(dev, "Unsupported IPsec algorithm - please use %s\n", 110 aes_gcm_name); 111 return -EINVAL; 112 } 113 114 /* 160 accounts for 16 byte key and 4 byte salt */ 115 if (key_len > NSIM_IPSEC_AUTH_BITS) { 116 *mysalt = ((u32 *)key_data)[4]; 117 } else if (key_len == NSIM_IPSEC_AUTH_BITS) { 118 *mysalt = 0; 119 } else { 120 netdev_err(dev, "IPsec hw offload only supports 128 bit keys with optional 32 bit salt\n"); 121 return -EINVAL; 122 } 123 memcpy(mykey, key_data, 16); 124 125 return 0; 126 } 127 128 static int nsim_ipsec_add_sa(struct xfrm_state *xs) 129 { 130 struct nsim_ipsec *ipsec; 131 struct net_device *dev; 132 struct netdevsim *ns; 133 struct nsim_sa sa; 134 u16 sa_idx; 135 int ret; 136 137 dev = xs->xso.dev; 138 ns = netdev_priv(dev); 139 ipsec = &ns->ipsec; 140 141 if (xs->id.proto != IPPROTO_ESP && xs->id.proto != IPPROTO_AH) { 142 netdev_err(dev, "Unsupported protocol 0x%04x for ipsec offload\n", 143 xs->id.proto); 144 return -EINVAL; 145 } 146 147 if (xs->calg) { 148 netdev_err(dev, "Compression offload not supported\n"); 149 return -EINVAL; 150 } 151 152 /* find the first unused index */ 153 ret = nsim_ipsec_find_empty_idx(ipsec); 154 if (ret < 0) { 155 netdev_err(dev, "No space for SA in Rx table!\n"); 156 return ret; 157 } 158 sa_idx = (u16)ret; 159 160 memset(&sa, 0, sizeof(sa)); 161 sa.used = true; 162 sa.xs = xs; 163 164 if (sa.xs->id.proto & IPPROTO_ESP) 165 sa.crypt = xs->ealg || xs->aead; 166 167 /* get the key and salt */ 168 ret = nsim_ipsec_parse_proto_keys(xs, sa.key, &sa.salt); 169 if (ret) { 170 netdev_err(dev, "Failed to get key data for SA table\n"); 171 return ret; 172 } 173 174 if (xs->xso.flags & XFRM_OFFLOAD_INBOUND) { 175 sa.rx = true; 176 177 if (xs->props.family == AF_INET6) 178 memcpy(sa.ipaddr, &xs->id.daddr.a6, 16); 179 else 180 memcpy(&sa.ipaddr[3], &xs->id.daddr.a4, 4); 181 } 182 183 /* the preparations worked, so save the info */ 184 memcpy(&ipsec->sa[sa_idx], &sa, sizeof(sa)); 185 186 /* the XFRM stack doesn't like offload_handle == 0, 187 * so add a bitflag in case our array index is 0 188 */ 189 xs->xso.offload_handle = sa_idx | NSIM_IPSEC_VALID; 190 ipsec->count++; 191 192 return 0; 193 } 194 195 static void nsim_ipsec_del_sa(struct xfrm_state *xs) 196 { 197 struct netdevsim *ns = netdev_priv(xs->xso.dev); 198 struct nsim_ipsec *ipsec = &ns->ipsec; 199 u16 sa_idx; 200 201 sa_idx = xs->xso.offload_handle & ~NSIM_IPSEC_VALID; 202 if (!ipsec->sa[sa_idx].used) { 203 netdev_err(ns->netdev, "Invalid SA for delete sa_idx=%d\n", 204 sa_idx); 205 return; 206 } 207 208 memset(&ipsec->sa[sa_idx], 0, sizeof(struct nsim_sa)); 209 ipsec->count--; 210 } 211 212 static bool nsim_ipsec_offload_ok(struct sk_buff *skb, struct xfrm_state *xs) 213 { 214 struct netdevsim *ns = netdev_priv(xs->xso.dev); 215 struct nsim_ipsec *ipsec = &ns->ipsec; 216 217 ipsec->ok++; 218 219 return true; 220 } 221 222 static const struct xfrmdev_ops nsim_xfrmdev_ops = { 223 .xdo_dev_state_add = nsim_ipsec_add_sa, 224 .xdo_dev_state_delete = nsim_ipsec_del_sa, 225 .xdo_dev_offload_ok = nsim_ipsec_offload_ok, 226 }; 227 228 bool nsim_ipsec_tx(struct netdevsim *ns, struct sk_buff *skb) 229 { 230 struct nsim_ipsec *ipsec = &ns->ipsec; 231 struct xfrm_state *xs; 232 struct nsim_sa *tsa; 233 u32 sa_idx; 234 235 /* do we even need to check this packet? */ 236 if (!skb->sp) 237 return true; 238 239 if (unlikely(!skb->sp->len)) { 240 netdev_err(ns->netdev, "no xfrm state len = %d\n", 241 skb->sp->len); 242 return false; 243 } 244 245 xs = xfrm_input_state(skb); 246 if (unlikely(!xs)) { 247 netdev_err(ns->netdev, "no xfrm_input_state() xs = %p\n", xs); 248 return false; 249 } 250 251 sa_idx = xs->xso.offload_handle & ~NSIM_IPSEC_VALID; 252 if (unlikely(sa_idx >= NSIM_IPSEC_MAX_SA_COUNT)) { 253 netdev_err(ns->netdev, "bad sa_idx=%d max=%d\n", 254 sa_idx, NSIM_IPSEC_MAX_SA_COUNT); 255 return false; 256 } 257 258 tsa = &ipsec->sa[sa_idx]; 259 if (unlikely(!tsa->used)) { 260 netdev_err(ns->netdev, "unused sa_idx=%d\n", sa_idx); 261 return false; 262 } 263 264 if (xs->id.proto != IPPROTO_ESP && xs->id.proto != IPPROTO_AH) { 265 netdev_err(ns->netdev, "unexpected proto=%d\n", xs->id.proto); 266 return false; 267 } 268 269 ipsec->tx++; 270 271 return true; 272 } 273 274 void nsim_ipsec_init(struct netdevsim *ns) 275 { 276 ns->netdev->xfrmdev_ops = &nsim_xfrmdev_ops; 277 278 #define NSIM_ESP_FEATURES (NETIF_F_HW_ESP | \ 279 NETIF_F_HW_ESP_TX_CSUM | \ 280 NETIF_F_GSO_ESP) 281 282 ns->netdev->features |= NSIM_ESP_FEATURES; 283 ns->netdev->hw_enc_features |= NSIM_ESP_FEATURES; 284 285 ns->ipsec.pfile = debugfs_create_file("ipsec", 0400, ns->ddir, ns, 286 &ipsec_dbg_fops); 287 } 288 289 void nsim_ipsec_teardown(struct netdevsim *ns) 290 { 291 struct nsim_ipsec *ipsec = &ns->ipsec; 292 293 if (ipsec->count) 294 netdev_err(ns->netdev, "tearing down IPsec offload with %d SAs left\n", 295 ipsec->count); 296 debugfs_remove_recursive(ipsec->pfile); 297 } 298