* [PATCH RFC net-next 4/5] net/ipv4: Update inet_dump_ifaddr to support NLM_F_DUMP_PROPER_HDR
From: dsahern @ 2018-09-28 15:45 UTC (permalink / raw)
To: netdev, davem; +Cc: christian, jbenc, stephen, David Ahern
In-Reply-To: <20180928154502.9983-1-dsahern@kernel.org>
From: David Ahern <dsahern@gmail.com>
Update inet_dump_ifaddr to check for NLM_F_DUMP_PROPER_HDR in the netlink
message header. If the flag is set, the dump request is expected to have
an ifaddrmsg struct as the header potentially followed by one or more
attributes. Any data passed in the header or as an attribute is taken as
a request to influence the data returned. Only values suppored by the
dump handler are allowed to be non-0 or set in the request. At the moment
only the IFA_TARGET_NETNSID attribute is supported. Follow on patches
will support for other fields (e.g., honor ifa_index and only return data
for the given device index).
Signed-off-by: David Ahern <dsahern@gmail.com>
---
net/ipv4/devinet.c | 52 +++++++++++++++++++++++++++++++++++++++++-----------
1 file changed, 41 insertions(+), 11 deletions(-)
diff --git a/net/ipv4/devinet.c b/net/ipv4/devinet.c
index 44d931a3cd50..1e06a21cd8f4 100644
--- a/net/ipv4/devinet.c
+++ b/net/ipv4/devinet.c
@@ -1661,15 +1661,15 @@ static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
{
+ struct netlink_ext_ack *extack = cb->extack;
+ const struct nlmsghdr *nlh = cb->nlh;
struct inet_fill_args fillargs = {
.portid = NETLINK_CB(cb->skb).portid,
- .seq = cb->nlh->nlmsg_seq,
+ .seq = nlh->nlmsg_seq,
.event = RTM_NEWADDR,
- .flags = NLM_F_MULTI,
.netnsid = -1,
};
struct net *net = sock_net(skb->sk);
- struct nlattr *tb[IFA_MAX+1];
struct net *tgt_net = net;
int h, s_h;
int idx, s_idx;
@@ -1683,15 +1683,45 @@ static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
s_idx = idx = cb->args[1];
s_ip_idx = ip_idx = cb->args[2];
- if (nlmsg_parse(cb->nlh, sizeof(struct ifaddrmsg), tb, IFA_MAX,
- ifa_ipv4_policy, NULL) >= 0) {
- if (tb[IFA_TARGET_NETNSID]) {
- fillargs.netnsid = nla_get_s32(tb[IFA_TARGET_NETNSID]);
+ if (nlh->nlmsg_flags & NLM_F_DUMP_PROPER_HDR) {
+ struct nlattr *tb[IFA_MAX+1];
+ struct ifaddrmsg *ifm;
+ int err, i;
+
+ if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
+ NL_SET_ERR_MSG(extack, "Invalid header");
+ return -EINVAL;
+ }
+
+ ifm = (struct ifaddrmsg *) nlmsg_data(cb->nlh);
+ if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
+ NL_SET_ERR_MSG(extack, "Invalid values in header for dump request");
+ return -EINVAL;
+ }
+ if (ifm->ifa_index) {
+ NL_SET_ERR_MSG(extack, "Filter by device index not supported");
+ return -EINVAL;
+ }
+ err = nlmsg_parse(cb->nlh, sizeof(struct ifaddrmsg), tb, IFA_MAX,
+ ifa_ipv4_policy, NULL);
+ if (err < 0)
+ return err;
- tgt_net = rtnl_get_net_ns_capable(skb->sk,
- fillargs.netnsid);
- if (IS_ERR(tgt_net))
- return PTR_ERR(tgt_net);
+ for (i = 0; i < IFA_MAX; ++i) {
+ if (i == IFA_TARGET_NETNSID) {
+ fillargs.netnsid = nla_get_s32(tb[i]);
+
+ tgt_net = rtnl_get_net_ns_capable(skb->sk,
+ fillargs.netnsid);
+ if (IS_ERR(tgt_net))
+ return PTR_ERR(tgt_net);
+
+ fillargs.flags |= NLM_F_DUMP_FILTERED;
+ }
+ if (tb[i]) {
+ NL_SET_ERR_MSG(extack, "Unsupported attribute in dump request");
+ return -EINVAL;
+ }
}
}
--
2.11.0
^ permalink raw reply related
* [PATCH RFC net-next 5/5] net/ipv6: Update inet6_dump_addr to support NLM_F_DUMP_PROPER_HDR
From: dsahern @ 2018-09-28 15:45 UTC (permalink / raw)
To: netdev, davem; +Cc: christian, jbenc, stephen, David Ahern
In-Reply-To: <20180928154502.9983-1-dsahern@kernel.org>
From: David Ahern <dsahern@gmail.com>
Update inet6_dump_addr to check for NLM_F_DUMP_PROPER_HDR in the netlink
message header. If the flag is set, the dump request is expected to have
an ifaddrmsg struct as the header potentially followed by one or more
attributes. Any data passed in the header or as an attribute is taken as
a request to influence the data returned. Only values suppored by the
dump handler are allowed to be non-0 or set in the request. At the moment
only the IFA_TARGET_NETNSID attribute is supported. Follow on patches
will support for other fields (e.g., honor ifa_index and only return data
for the given device index).
Signed-off-by: David Ahern <dsahern@gmail.com>
---
net/ipv6/addrconf.c | 50 ++++++++++++++++++++++++++++++++++++++++----------
1 file changed, 40 insertions(+), 10 deletions(-)
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index 375ea9d9869b..888e5a4b8dd2 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -5001,6 +5001,8 @@ static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
enum addr_type_t type)
{
+ struct netlink_ext_ack *extack = cb->extack;
+ const struct nlmsghdr *nlh = cb->nlh;
struct inet6_fill_args fillargs = {
.portid = NETLINK_CB(cb->skb).portid,
.seq = cb->nlh->nlmsg_seq,
@@ -5009,7 +5011,6 @@ static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
.type = type,
};
struct net *net = sock_net(skb->sk);
- struct nlattr *tb[IFA_MAX+1];
struct net *tgt_net = net;
int h, s_h;
int idx, ip_idx;
@@ -5022,17 +5023,46 @@ static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
s_idx = idx = cb->args[1];
s_ip_idx = ip_idx = cb->args[2];
- if (nlmsg_parse(cb->nlh, sizeof(struct ifaddrmsg), tb, IFA_MAX,
- ifa_ipv6_policy, NULL) >= 0) {
- if (tb[IFA_TARGET_NETNSID]) {
- fillargs.netnsid = nla_get_s32(tb[IFA_TARGET_NETNSID]);
+ if (nlh->nlmsg_flags & NLM_F_DUMP_PROPER_HDR) {
+ struct nlattr *tb[IFA_MAX+1];
+ struct ifaddrmsg *ifm;
+ int err, i;
+
+ if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
+ NL_SET_ERR_MSG(extack, "Invalid header");
+ return -EINVAL;
+ }
- tgt_net = rtnl_get_net_ns_capable(skb->sk,
- fillargs.netnsid);
- if (IS_ERR(tgt_net))
- return PTR_ERR(tgt_net);
+ ifm = (struct ifaddrmsg *)nlmsg_data(cb->nlh);
+ if (ifm->ifa_prefixlen || ifm->ifa_flags || ifm->ifa_scope) {
+ NL_SET_ERR_MSG(extack, "Invalid values in header for dump request");
+ return -EINVAL;
+ }
+ if (ifm->ifa_index) {
+ NL_SET_ERR_MSG(extack, "Filter by device index not supported");
+ return -EINVAL;
+ }
- fillargs.flags |= NLM_F_DUMP_FILTERED;
+ err = nlmsg_parse(cb->nlh, sizeof(struct ifaddrmsg), tb, IFA_MAX,
+ ifa_ipv6_policy, NULL);
+ if (err < 0)
+ return err;
+
+ for (i = 0; i < IFA_MAX; ++i) {
+ if (i == IFA_TARGET_NETNSID) {
+ fillargs.netnsid = nla_get_s32(tb[i]);
+
+ tgt_net = rtnl_get_net_ns_capable(skb->sk,
+ fillargs.netnsid);
+ if (IS_ERR(tgt_net))
+ return PTR_ERR(tgt_net);
+
+ fillargs.flags |= NLM_F_DUMP_FILTERED;
+ }
+ if (tb[i]) {
+ NL_SET_ERR_MSG(extack, "Unsupported attribute in dump request");
+ return -EINVAL;
+ }
}
}
--
2.11.0
^ permalink raw reply related
* [PATCH RFC net-next 2/5] net/ipv6: Refactor address dump to push inet6_fill_args to in6_dump_addrs
From: dsahern @ 2018-09-28 15:44 UTC (permalink / raw)
To: netdev, davem; +Cc: christian, jbenc, stephen, David Ahern
In-Reply-To: <20180928154502.9983-1-dsahern@kernel.org>
From: David Ahern <dsahern@gmail.com>
Pull the inet6_fill_args arg up to in6_dump_addrs and move netnsid
into it. Since IFA_TARGET_NETNSID is a kernel side filter add the
NLM_F_DUMP_FILTERED flag so userspace knows the request was honored.
Signed-off-by: David Ahern <dsahern@gmail.com>
---
net/ipv6/addrconf.c | 59 +++++++++++++++++++++++++++++------------------------
1 file changed, 32 insertions(+), 27 deletions(-)
diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index a9a317322388..375ea9d9869b 100644
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -4793,12 +4793,19 @@ static inline int inet6_ifaddr_msgsize(void)
+ nla_total_size(4) /* IFA_RT_PRIORITY */;
}
+enum addr_type_t {
+ UNICAST_ADDR,
+ MULTICAST_ADDR,
+ ANYCAST_ADDR,
+};
+
struct inet6_fill_args {
u32 portid;
u32 seq;
int event;
unsigned int flags;
int netnsid;
+ enum addr_type_t type;
};
static int inet6_fill_ifaddr(struct sk_buff *skb, struct inet6_ifaddr *ifa,
@@ -4930,39 +4937,28 @@ static int inet6_fill_ifacaddr(struct sk_buff *skb, struct ifacaddr6 *ifaca,
return 0;
}
-enum addr_type_t {
- UNICAST_ADDR,
- MULTICAST_ADDR,
- ANYCAST_ADDR,
-};
-
/* called with rcu_read_lock() */
static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
- struct netlink_callback *cb, enum addr_type_t type,
- int s_ip_idx, int *p_ip_idx, int netnsid)
+ struct netlink_callback *cb,
+ int s_ip_idx, int *p_ip_idx,
+ struct inet6_fill_args *fillargs)
{
- struct inet6_fill_args fillargs = {
- .portid = NETLINK_CB(cb->skb).portid,
- .seq = cb->nlh->nlmsg_seq,
- .flags = NLM_F_MULTI,
- .netnsid = netnsid,
- };
struct ifmcaddr6 *ifmca;
struct ifacaddr6 *ifaca;
int err = 1;
int ip_idx = *p_ip_idx;
read_lock_bh(&idev->lock);
- switch (type) {
+ switch (fillargs->type) {
case UNICAST_ADDR: {
struct inet6_ifaddr *ifa;
- fillargs.event = RTM_NEWADDR;
+ fillargs->event = RTM_NEWADDR;
/* unicast address incl. temp addr */
list_for_each_entry(ifa, &idev->addr_list, if_list) {
if (++ip_idx < s_ip_idx)
continue;
- err = inet6_fill_ifaddr(skb, ifa, &fillargs);
+ err = inet6_fill_ifaddr(skb, ifa, fillargs);
if (err < 0)
break;
nl_dump_check_consistent(cb, nlmsg_hdr(skb));
@@ -4970,26 +4966,26 @@ static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
break;
}
case MULTICAST_ADDR:
- fillargs.event = RTM_GETMULTICAST;
+ fillargs->event = RTM_GETMULTICAST;
/* multicast address */
for (ifmca = idev->mc_list; ifmca;
ifmca = ifmca->next, ip_idx++) {
if (ip_idx < s_ip_idx)
continue;
- err = inet6_fill_ifmcaddr(skb, ifmca, &fillargs);
+ err = inet6_fill_ifmcaddr(skb, ifmca, fillargs);
if (err < 0)
break;
}
break;
case ANYCAST_ADDR:
- fillargs.event = RTM_GETANYCAST;
+ fillargs->event = RTM_GETANYCAST;
/* anycast address */
for (ifaca = idev->ac_list; ifaca;
ifaca = ifaca->aca_next, ip_idx++) {
if (ip_idx < s_ip_idx)
continue;
- err = inet6_fill_ifacaddr(skb, ifaca, &fillargs);
+ err = inet6_fill_ifacaddr(skb, ifaca, fillargs);
if (err < 0)
break;
}
@@ -5005,10 +5001,16 @@ static int in6_dump_addrs(struct inet6_dev *idev, struct sk_buff *skb,
static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
enum addr_type_t type)
{
+ struct inet6_fill_args fillargs = {
+ .portid = NETLINK_CB(cb->skb).portid,
+ .seq = cb->nlh->nlmsg_seq,
+ .flags = NLM_F_MULTI,
+ .netnsid = -1,
+ .type = type,
+ };
struct net *net = sock_net(skb->sk);
struct nlattr *tb[IFA_MAX+1];
struct net *tgt_net = net;
- int netnsid = -1;
int h, s_h;
int idx, ip_idx;
int s_idx, s_ip_idx;
@@ -5023,11 +5025,14 @@ static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
if (nlmsg_parse(cb->nlh, sizeof(struct ifaddrmsg), tb, IFA_MAX,
ifa_ipv6_policy, NULL) >= 0) {
if (tb[IFA_TARGET_NETNSID]) {
- netnsid = nla_get_s32(tb[IFA_TARGET_NETNSID]);
+ fillargs.netnsid = nla_get_s32(tb[IFA_TARGET_NETNSID]);
- tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
+ tgt_net = rtnl_get_net_ns_capable(skb->sk,
+ fillargs.netnsid);
if (IS_ERR(tgt_net))
return PTR_ERR(tgt_net);
+
+ fillargs.flags |= NLM_F_DUMP_FILTERED;
}
}
@@ -5046,8 +5051,8 @@ static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
if (!idev)
goto cont;
- if (in6_dump_addrs(idev, skb, cb, type,
- s_ip_idx, &ip_idx, netnsid) < 0)
+ if (in6_dump_addrs(idev, skb, cb, s_ip_idx, &ip_idx,
+ &fillargs) < 0)
goto done;
cont:
idx++;
@@ -5058,7 +5063,7 @@ static int inet6_dump_addr(struct sk_buff *skb, struct netlink_callback *cb,
cb->args[0] = h;
cb->args[1] = idx;
cb->args[2] = ip_idx;
- if (netnsid >= 0)
+ if (fillargs.netnsid >= 0)
put_net(tgt_net);
return skb->len;
--
2.11.0
^ permalink raw reply related
* [PATCH RFC net-next 3/5] netlink: introduce NLM_F_DUMP_PROPER_HDR flag
From: dsahern @ 2018-09-28 15:45 UTC (permalink / raw)
To: netdev, davem; +Cc: christian, jbenc, stephen, David Ahern
In-Reply-To: <20180928154502.9983-1-dsahern@kernel.org>
From: David Ahern <dsahern@gmail.com>
Add a new flag, NLM_F_DUMP_PROPER_HDR, for userspace to indicate to the
kernel that it believes it is sending the right header struct for the
dump message type (ifinfomsg, ifaddrmsg, rtmsg, fib_rule_hdr, ...).
Setting the flag in the netlink message header indicates to the kernel
it should do rigid checking on all data passed in the dump request and
filter the data returned based on data passed in.
Signed-off-by: David Ahern <dsahern@gmail.com>
---
include/uapi/linux/netlink.h | 1 +
1 file changed, 1 insertion(+)
diff --git a/include/uapi/linux/netlink.h b/include/uapi/linux/netlink.h
index 776bc92e9118..e722bed88dee 100644
--- a/include/uapi/linux/netlink.h
+++ b/include/uapi/linux/netlink.h
@@ -57,6 +57,7 @@ struct nlmsghdr {
#define NLM_F_ECHO 0x08 /* Echo this request */
#define NLM_F_DUMP_INTR 0x10 /* Dump was inconsistent due to sequence change */
#define NLM_F_DUMP_FILTERED 0x20 /* Dump was filtered as requested */
+#define NLM_F_DUMP_PROPER_HDR 0x40 /* Dump request has the proper header for type */
/* Modifiers to GET request */
#define NLM_F_ROOT 0x100 /* specify tree root */
--
2.11.0
^ permalink raw reply related
* [PATCH RFC net-next 1/5] net/netlink: Pass extack to dump callbacks
From: dsahern @ 2018-09-28 15:44 UTC (permalink / raw)
To: netdev, davem; +Cc: christian, jbenc, stephen, David Ahern
In-Reply-To: <20180928154502.9983-1-dsahern@kernel.org>
From: David Ahern <dsahern@gmail.com>
Pass extack to dump callbacks by adding extack to netlink_dump_control
and transferring to netlink_callback. Update rtnetlink as the first
user.
Signed-off-by: David Ahern <dsahern@gmail.com>
---
include/linux/netlink.h | 2 ++
net/core/rtnetlink.c | 1 +
net/netlink/af_netlink.c | 1 +
3 files changed, 4 insertions(+)
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 71f121b66ca8..8fc90308a653 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -176,6 +176,7 @@ struct netlink_callback {
void *data;
/* the module that dump function belong to */
struct module *module;
+ struct netlink_ext_ack *extack;
u16 family;
u16 min_dump_alloc;
unsigned int prev_seq, seq;
@@ -197,6 +198,7 @@ struct netlink_dump_control {
int (*done)(struct netlink_callback *);
void *data;
struct module *module;
+ struct netlink_ext_ack *extack;
u16 min_dump_alloc;
};
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index 35162e1b06ad..da91b38297d3 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -4689,6 +4689,7 @@ static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
.dump = dumpit,
.min_dump_alloc = min_dump_alloc,
.module = owner,
+ .extack = extack
};
err = netlink_dump_start(rtnl, skb, nlh, &c);
/* netlink_dump_start() will keep a reference on
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index e3a0538ec0be..7d9e735b32c4 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -2307,6 +2307,7 @@ int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb,
cb->module = control->module;
cb->min_dump_alloc = control->min_dump_alloc;
cb->skb = skb;
+ cb->extack = control->extack;
if (control->start) {
ret = control->start(cb);
--
2.11.0
^ permalink raw reply related
* [PATCH RFC net-next 0/5] rtnetlink: Add support for rigid checking of data in dump request
From: dsahern @ 2018-09-28 15:44 UTC (permalink / raw)
To: netdev, davem; +Cc: christian, jbenc, stephen, David Ahern
From: David Ahern <dsahern@gmail.com>
There are many use cases where a user wants to influence what is
returned in a dump for some rtnetlink command: one is wanting data
for a different namespace than the one the request is received and
another is limiting the amount of data returned in the dump to a
specific set of interest to userspace, reducing the cpu overhead of
both kernel and userspace. Unfortunately, the kernel has historically
not been strict with checking for the proper header or checking the
values passed in the header. This lenient implementation has allowed
iproute2 and other packages to pass any struct or data in the dump
request as long as the family is the first byte. For example, ifinfomsg
struct is used by iproute2 for all generic dump requests - links,
addresses, routes and rules when it is really only valid for link
requests.
There is 1 is example where the kernel deals with the wrong struct: link
dumps after VF support was added. Older iproute2 was sending rtgenmsg as
the header instead of ifinfomsg so a patch was added to try and detect
old userspace vs new:
e5eca6d41f53 ("rtnetlink: fix userspace API breakage for iproute2 < v3.9.0")
The latest example is Christian's patch set wanting to return addresses for
a target namespace. It guesses the header struct is an ifaddrmsg and if it
guesses wrong a netlink warning is generated in the kernel log on every
address dump which is unacceptable.
Another example where the kernel is a bit lenient is route dumps: iproute2
can send either a request with either ifinfomsg or a rtmsg as the header
struct, yet the kernel always treats the header as an rtmsg (see
inet_dump_fib and rtm_flags check).
How to resolve the problem of not breaking old userspace yet be able to
move forward with new features such as kernel side filtering which are
crucial for efficient operation at high scale?
This patch set addresses the problem by adding a new netlink flag,
NLM_F_DUMP_PROPER_HDR, that userspace can set to say "I have a clue, and
I am sending the right header struct" and that the struct fields and any
attributes after it should be used for filtering the data returned in the
dump.
Kernel side, the dump handlers are updated to check every field in the
header struct and all attributes passed. Only ones where filtering is
implemented are allowed to be set. Any other values cause the dump to fail
with EINVAL. If the new flag is honored by the kernel and the dump contents
adjusted by any data passed in the request, the dump handler sets the
NLM_F_DUMP_FILTERED flag in the netlink message header.
This is an RFC set with the address handlers updated. If the approach is
acceptable, then I will do the same to the other rtnetlink dump handlers.
David Ahern (5):
net/netlink: Pass extack to dump callbacks
net/ipv6: Refactor address dump to push inet6_fill_args to
in6_dump_addrs
netlink: introduce NLM_F_DUMP_PROPER_HDR flag
net/ipv4: Update inet_dump_ifaddr to support NLM_F_DUMP_PROPER_HDR
net/ipv6: Update inet6_dump_addr to support NLM_F_DUMP_PROPER_HDR
include/linux/netlink.h | 2 +
include/uapi/linux/netlink.h | 1 +
net/core/rtnetlink.c | 1 +
net/ipv4/devinet.c | 52 +++++++++++++++++-----
net/ipv6/addrconf.c | 101 +++++++++++++++++++++++++++++--------------
net/netlink/af_netlink.c | 1 +
6 files changed, 114 insertions(+), 44 deletions(-)
--
2.11.0
^ permalink raw reply
* Bad MAINTAINERS pattern in section 'VIRTIO AND VHOST VSOCK DRIVER'
From: Joe Perches @ 2018-09-28 22:05 UTC (permalink / raw)
To: linux-kernel
Cc: Stefan Hajnoczi, kvm, virtualization, netdev, David S . Miller
Please fix this defect appropriately.
linux-next MAINTAINERS section:
15660 VIRTIO AND VHOST VSOCK DRIVER
15661 M: Stefan Hajnoczi <stefanha@redhat.com>
15662 L: kvm@vger.kernel.org
15663 L: virtualization@lists.linux-foundation.org
15664 L: netdev@vger.kernel.org
15665 S: Maintained
15666 F: include/linux/virtio_vsock.h
15667 F: include/uapi/linux/virtio_vsock.h
15668 F: include/uapi/linux/vsockmon.h
15669 F: include/uapi/linux/vm_sockets_diag.h
15670 F: net/vmw_vsock/diag.c
15671 F: net/vmw_vsock/af_vsock_tap.c
15672 F: net/vmw_vsock/virtio_transport_common.c
15673 F: net/vmw_vsock/virtio_transport.c
15674 F: drivers/net/vsockmon.c
15675 F: drivers/vhost/vsock.c
--> 15676 F: drivers/vhost/vsock.h
15677 F: tools/testing/vsock/
Commit that introduced this:
commit 433fc58e6bf2c8bd97e57153ed28e64fd78207b8
Author: Asias He <asias@redhat.com>
Date: Thu Jul 28 15:36:34 2016 +0100
VSOCK: Introduce vhost_vsock.ko
VM sockets vhost transport implementation. This driver runs on the
host.
Signed-off-by: Asias He <asias@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
MAINTAINERS | 2 +
drivers/vhost/vsock.c | 722 +++++++++++++++++++++++++++++++++++++++++++++
include/uapi/linux/vhost.h | 5 +
3 files changed, 729 insertions(+)
Last commit with drivers/vhost/vsock.h
commit 8ac2837c89c8c0fcad557e4380aeef80580390f9
Author: Stefan Hajnoczi <stefanha@redhat.com>
Date: Wed Dec 9 10:51:12 2015 +0800
Revert "Merge branch 'vsock-virtio'"
This reverts commit 0d76d6e8b2507983a2cae4c09880798079007421 and merge
commit c402293bd76fbc93e52ef8c0947ab81eea3ae019, reversing changes made
to c89359a42e2a49656451569c382eed63e781153c.
The virtio-vsock device specification is not finalized yet. Michael
Tsirkin voiced concerned about merging this code when the hardware
interface (and possibly the userspace interface) could still change.
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
drivers/vhost/Kconfig | 4 -
drivers/vhost/Kconfig.vsock | 7 -
drivers/vhost/Makefile | 4 -
drivers/vhost/vsock.c | 630 ---------------
drivers/vhost/vsock.h | 4 -
include/linux/virtio_vsock.h | 209 -----
include/net/af_vsock.h | 2 -
include/uapi/linux/virtio_ids.h | 1 -
include/uapi/linux/virtio_vsock.h | 89 ---
net/vmw_vsock/Kconfig | 18 -
net/vmw_vsock/Makefile | 2 -
net/vmw_vsock/af_vsock.c | 70 --
net/vmw_vsock/virtio_transport.c | 466 -----------
net/vmw_vsock/virtio_transport_common.c | 1272 -------------------------------
14 files changed, 2778 deletions(-)
^ permalink raw reply
* [PATCH RESEND] net: phy: Convert to using %pOFn instead of device_node.name
From: Rob Herring @ 2018-09-28 22:04 UTC (permalink / raw)
To: David S. Miller; +Cc: linux-kernel, Andrew Lunn, netdev, Florian Fainelli
In preparation to remove the node name pointer from struct device_node,
convert printf users to use the %pOFn format specifier.
Cc: Andrew Lunn <andrew@lunn.ch>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: netdev@vger.kernel.org
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: Rob Herring <robh@kernel.org>
---
David, Resending because you superseded this one for some reason. It
shouldn't be. Perhaps because the subject was similar to others?
Rob
drivers/net/phy/mdio-thunder.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/net/phy/mdio-thunder.c b/drivers/net/phy/mdio-thunder.c
index 564616968cad..1546f6398831 100644
--- a/drivers/net/phy/mdio-thunder.c
+++ b/drivers/net/phy/mdio-thunder.c
@@ -73,8 +73,8 @@ static int thunder_mdiobus_pci_probe(struct pci_dev *pdev,
err = of_address_to_resource(node, 0, &r);
if (err) {
dev_err(&pdev->dev,
- "Couldn't translate address for \"%s\"\n",
- node->name);
+ "Couldn't translate address for \"%pOFn\"\n",
+ node);
break;
}
--
2.17.1
^ permalink raw reply related
* Re: [PATCH net-next v6 03/23] zinc: ChaCha20 generic C implementation and selftest
From: Ard Biesheuvel @ 2018-09-28 15:40 UTC (permalink / raw)
To: Jason A. Donenfeld
Cc: Linux Kernel Mailing List, <netdev@vger.kernel.org>,
open list:HARDWARE RANDOM NUMBER GENERATOR CORE, David S. Miller,
Greg Kroah-Hartman, Samuel Neves, Andy Lutomirski,
Jean-Philippe Aumasson
In-Reply-To: <20180925145622.29959-4-Jason@zx2c4.com>
On 25 September 2018 at 16:56, Jason A. Donenfeld <Jason@zx2c4.com> wrote:
> This implements the ChaCha20 permutation as a single C statement, by way
> of the comma operator, which the compiler is able to simplify
> terrifically.
>
> Information: https://cr.yp.to/chacha.html
>
> Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
> Cc: Samuel Neves <sneves@dei.uc.pt>
> Cc: Andy Lutomirski <luto@kernel.org>
> Cc: Greg KH <gregkh@linuxfoundation.org>
> Cc: Jean-Philippe Aumasson <jeanphilippe.aumasson@gmail.com>
> ---
> include/zinc/chacha20.h | 65 +
> lib/zinc/Kconfig | 4 +
> lib/zinc/Makefile | 3 +
> lib/zinc/chacha20/chacha20.c | 179 +++
> lib/zinc/selftest/chacha20.h | 2676 ++++++++++++++++++++++++++++++++++
> 5 files changed, 2927 insertions(+)
> create mode 100644 include/zinc/chacha20.h
> create mode 100644 lib/zinc/chacha20/chacha20.c
> create mode 100644 lib/zinc/selftest/chacha20.h
>
> diff --git a/include/zinc/chacha20.h b/include/zinc/chacha20.h
> new file mode 100644
> index 000000000000..14bbadd242c9
> --- /dev/null
> +++ b/include/zinc/chacha20.h
> @@ -0,0 +1,65 @@
> +/* SPDX-License-Identifier: GPL-2.0 OR MIT */
> +/*
> + * Copyright (C) 2015-2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
> + */
> +
> +#ifndef _ZINC_CHACHA20_H
> +#define _ZINC_CHACHA20_H
> +
> +#include <asm/unaligned.h>
> +#include <linux/simd.h>
> +#include <linux/kernel.h>
> +#include <linux/types.h>
> +
> +enum {
> + CHACHA20_NONCE_SIZE = 16,
> + CHACHA20_KEY_SIZE = 32,
> + CHACHA20_KEY_WORDS = CHACHA20_KEY_SIZE / sizeof(u32),
> + CHACHA20_BLOCK_SIZE = 64,
> + CHACHA20_BLOCK_WORDS = CHACHA20_BLOCK_SIZE / sizeof(u32),
> + HCHACHA20_NONCE_SIZE = CHACHA20_NONCE_SIZE,
> + HCHACHA20_KEY_SIZE = CHACHA20_KEY_SIZE
> +};
> +
> +enum { /* expand 32-byte k */
> + CHACHA20_CONSTANT_EXPA = 0x61707865U,
> + CHACHA20_CONSTANT_ND_3 = 0x3320646eU,
> + CHACHA20_CONSTANT_2_BY = 0x79622d32U,
> + CHACHA20_CONSTANT_TE_K = 0x6b206574U
> +};
> +
> +struct chacha20_ctx {
> + u32 constant[4];
> + u32 key[8];
> + u32 counter[4];
> +} __aligned(32);
> +
32 *byte* alignment? Is that right? If this is for performance and it
actually helps, using __cacheline_aligned is more appropriate,
> +static inline void chacha20_init(struct chacha20_ctx *state,
> + const u8 key[CHACHA20_KEY_SIZE],
> + const u64 nonce)
> +{
> + state->constant[0] = CHACHA20_CONSTANT_EXPA;
> + state->constant[1] = CHACHA20_CONSTANT_ND_3;
> + state->constant[2] = CHACHA20_CONSTANT_2_BY;
> + state->constant[3] = CHACHA20_CONSTANT_TE_K;
> + state->key[0] = get_unaligned_le32(key + 0);
> + state->key[1] = get_unaligned_le32(key + 4);
> + state->key[2] = get_unaligned_le32(key + 8);
> + state->key[3] = get_unaligned_le32(key + 12);
> + state->key[4] = get_unaligned_le32(key + 16);
> + state->key[5] = get_unaligned_le32(key + 20);
> + state->key[6] = get_unaligned_le32(key + 24);
> + state->key[7] = get_unaligned_le32(key + 28);
> + state->counter[0] = 0;
> + state->counter[1] = 0;
> + state->counter[2] = nonce & U32_MAX;
> + state->counter[3] = nonce >> 32;
> +}
> +void chacha20(struct chacha20_ctx *state, u8 *dst, const u8 *src, u32 len,
> + simd_context_t *simd_context);
> +
> +void hchacha20(u32 derived_key[CHACHA20_KEY_WORDS],
> + const u8 nonce[HCHACHA20_NONCE_SIZE],
> + const u8 key[HCHACHA20_KEY_SIZE], simd_context_t *simd_context);
> +
> +#endif /* _ZINC_CHACHA20_H */
> diff --git a/lib/zinc/Kconfig b/lib/zinc/Kconfig
> index 4e2e59126a67..1ca1ae1e9ea9 100644
> --- a/lib/zinc/Kconfig
> +++ b/lib/zinc/Kconfig
> @@ -1,3 +1,7 @@
> +config ZINC_CHACHA20
> + tristate
> + select CRYPTO_ALGAPI
> +
> config ZINC_DEBUG
> bool "Zinc cryptography library debugging and self-tests"
> help
> diff --git a/lib/zinc/Makefile b/lib/zinc/Makefile
> index a61c80d676cb..3d80144d55a6 100644
> --- a/lib/zinc/Makefile
> +++ b/lib/zinc/Makefile
> @@ -1,3 +1,6 @@
> ccflags-y := -O2
> ccflags-y += -D'pr_fmt(fmt)="zinc: " fmt'
> ccflags-$(CONFIG_ZINC_DEBUG) += -DDEBUG
> +
> +zinc_chacha20-y := chacha20/chacha20.o
> +obj-$(CONFIG_ZINC_CHACHA20) += zinc_chacha20.o
> diff --git a/lib/zinc/chacha20/chacha20.c b/lib/zinc/chacha20/chacha20.c
> new file mode 100644
> index 000000000000..c82d9fc71f21
> --- /dev/null
> +++ b/lib/zinc/chacha20/chacha20.c
> @@ -0,0 +1,179 @@
> +// SPDX-License-Identifier: GPL-2.0 OR MIT
> +/*
> + * Copyright (C) 2015-2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
> + *
> + * Implementation of the ChaCha20 stream cipher.
> + *
> + * Information: https://cr.yp.to/chacha.html
> + */
> +
> +#include <zinc/chacha20.h>
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <crypto/algapi.h>
> +
I guess this include is for crypto_xor_cpy() ?
We may want to put a comment here, so we keep track of the interdependencies.
> +#ifndef HAVE_CHACHA20_ARCH_IMPLEMENTATION
This #define is never set in subsequent patches, so just drop this
#ifndef entirely (for this patch only)
> +void __init chacha20_fpu_init(void)
> +{
> +}
> +static inline bool chacha20_arch(struct chacha20_ctx *state, u8 *out,
> + const u8 *in, const size_t len,
> + simd_context_t *simd_context)
> +{
> + return false;
> +}
> +static inline bool hchacha20_arch(u32 derived_key[CHACHA20_KEY_WORDS],
> + const u8 nonce[HCHACHA20_NONCE_SIZE],
> + const u8 key[HCHACHA20_KEY_SIZE],
> + simd_context_t *simd_context)
> +{
> + return false;
> +}
> +#endif
> +
> +#define QUARTER_ROUND(x, a, b, c, d) ( \
> + x[a] += x[b], \
> + x[d] = rol32((x[d] ^ x[a]), 16), \
> + x[c] += x[d], \
> + x[b] = rol32((x[b] ^ x[c]), 12), \
> + x[a] += x[b], \
> + x[d] = rol32((x[d] ^ x[a]), 8), \
> + x[c] += x[d], \
> + x[b] = rol32((x[b] ^ x[c]), 7) \
> +)
> +
> +#define C(i, j) (i * 4 + j)
> +
> +#define DOUBLE_ROUND(x) ( \
> + /* Column Round */ \
> + QUARTER_ROUND(x, C(0, 0), C(1, 0), C(2, 0), C(3, 0)), \
> + QUARTER_ROUND(x, C(0, 1), C(1, 1), C(2, 1), C(3, 1)), \
> + QUARTER_ROUND(x, C(0, 2), C(1, 2), C(2, 2), C(3, 2)), \
> + QUARTER_ROUND(x, C(0, 3), C(1, 3), C(2, 3), C(3, 3)), \
> + /* Diagonal Round */ \
> + QUARTER_ROUND(x, C(0, 0), C(1, 1), C(2, 2), C(3, 3)), \
> + QUARTER_ROUND(x, C(0, 1), C(1, 2), C(2, 3), C(3, 0)), \
> + QUARTER_ROUND(x, C(0, 2), C(1, 3), C(2, 0), C(3, 1)), \
> + QUARTER_ROUND(x, C(0, 3), C(1, 0), C(2, 1), C(3, 2)) \
> +)
> +
> +#define TWENTY_ROUNDS(x) ( \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x), \
> + DOUBLE_ROUND(x) \
> +)
> +
> +static void chacha20_block_generic(__le32 *stream, u32 *state)
> +{
> + u32 x[CHACHA20_BLOCK_WORDS];
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(x); ++i)
> + x[i] = state[i];
> +
> + TWENTY_ROUNDS(x);
> +
> + for (i = 0; i < ARRAY_SIZE(x); ++i)
> + stream[i] = cpu_to_le32(x[i] + state[i]);
> +
> + ++state[12];
> +}
> +
> +static void chacha20_generic(struct chacha20_ctx *state, u8 *out, const u8 *in,
> + u32 len)
> +{
> + __le32 buf[CHACHA20_BLOCK_WORDS];
> +
> + while (len >= CHACHA20_BLOCK_SIZE) {
> + chacha20_block_generic(buf, (u32 *)state);
> + crypto_xor_cpy(out, in, (u8 *)buf, CHACHA20_BLOCK_SIZE);
> + len -= CHACHA20_BLOCK_SIZE;
> + out += CHACHA20_BLOCK_SIZE;
> + in += CHACHA20_BLOCK_SIZE;
> + }
> + if (len) {
> + chacha20_block_generic(buf, (u32 *)state);
> + crypto_xor_cpy(out, in, (u8 *)buf, len);
> + }
> +}
> +
> +void chacha20(struct chacha20_ctx *state, u8 *dst, const u8 *src, u32 len,
> + simd_context_t *simd_context)
> +{
> + if (!chacha20_arch(state, dst, src, len, simd_context))
> + chacha20_generic(state, dst, src, len);
> +}
> +EXPORT_SYMBOL(chacha20);
> +
> +static void hchacha20_generic(u32 derived_key[CHACHA20_KEY_WORDS],
> + const u8 nonce[HCHACHA20_NONCE_SIZE],
> + const u8 key[HCHACHA20_KEY_SIZE])
> +{
> + u32 x[] = { CHACHA20_CONSTANT_EXPA,
> + CHACHA20_CONSTANT_ND_3,
> + CHACHA20_CONSTANT_2_BY,
> + CHACHA20_CONSTANT_TE_K,
> + get_unaligned_le32(key + 0),
> + get_unaligned_le32(key + 4),
> + get_unaligned_le32(key + 8),
> + get_unaligned_le32(key + 12),
> + get_unaligned_le32(key + 16),
> + get_unaligned_le32(key + 20),
> + get_unaligned_le32(key + 24),
> + get_unaligned_le32(key + 28),
> + get_unaligned_le32(nonce + 0),
> + get_unaligned_le32(nonce + 4),
> + get_unaligned_le32(nonce + 8),
> + get_unaligned_le32(nonce + 12)
> + };
> +
> + TWENTY_ROUNDS(x);
> +
> + memcpy(derived_key + 0, x + 0, sizeof(u32) * 4);
> + memcpy(derived_key + 4, x + 12, sizeof(u32) * 4);
> +}
> +
> +/* Derived key should be 32-bit aligned */
> +void hchacha20(u32 derived_key[CHACHA20_KEY_WORDS],
> + const u8 nonce[HCHACHA20_NONCE_SIZE],
> + const u8 key[HCHACHA20_KEY_SIZE], simd_context_t *simd_context)
> +{
> + if (!hchacha20_arch(derived_key, nonce, key, simd_context))
> + hchacha20_generic(derived_key, nonce, key);
> +}
> +EXPORT_SYMBOL(hchacha20);
> +
> +#include "../selftest/chacha20.h"
> +
> +static bool nosimd __initdata = false;
> +
> +static int __init mod_init(void)
> +{
> + if (!nosimd)
> + chacha20_fpu_init();
> +#ifdef DEBUG
> + if (!chacha20_selftest())
> + return -ENOTRECOVERABLE;
Return values from initcalls are ignored, and given that chacha20 will
be depended upon by random.c, it will never be a module in practice.
Given your previous statement that selftest should *not* be a DEBUG
feature (which I wholeheartedly agree with), you could be a bit
noisier here imo.
E.g.,
if (WARN_ON(!chach20_selftest())
return ...
> +#endif
> + return 0;
> +}
> +
> +static void __exit mod_exit(void)
> +{
> +}
> +
> +module_param(nosimd, bool, 0);
> +module_init(mod_init);
> +module_exit(mod_exit);
> +MODULE_LICENSE("GPL v2");
> +MODULE_DESCRIPTION("ChaCha20 stream cipher");
> +MODULE_AUTHOR("Jason A. Donenfeld <Jason@zx2c4.com>");
> diff --git a/lib/zinc/selftest/chacha20.h b/lib/zinc/selftest/chacha20.h
> new file mode 100644
> index 000000000000..397a4b930fd7
> --- /dev/null
> +++ b/lib/zinc/selftest/chacha20.h
> @@ -0,0 +1,2676 @@
> +/* SPDX-License-Identifier: GPL-2.0 OR MIT */
> +/*
> + * Copyright (C) 2015-2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
> + */
> +
> +#ifdef DEBUG
> +
> +struct chacha20_testvec {
> + const u8 *input, *output, *key;
> + u64 nonce;
> + size_t ilen;
> +};
> +
> +struct hchacha20_testvec {
> + u8 key[HCHACHA20_KEY_SIZE];
> + u8 nonce[HCHACHA20_NONCE_SIZE];
> + u8 output[CHACHA20_KEY_SIZE];
> +};
> +
> +/* These test vectors are generated by reference implementations and are
> + * designed to check chacha20 implementation block handling, as well as from
> + * the draft-arciszewski-xchacha-01 document.
> + */
> +
> +static const u8 input01[] __initconst = { };
> +static const u8 output01[] __initconst = { };
> +static const u8 key01[] __initconst = {
> + 0x09, 0xf4, 0xe8, 0x57, 0x10, 0xf2, 0x12, 0xc3,
> + 0xc6, 0x91, 0xc4, 0x09, 0x97, 0x46, 0xef, 0xfe,
> + 0x02, 0x00, 0xe4, 0x5c, 0x82, 0xed, 0x16, 0xf3,
> + 0x32, 0xbe, 0xec, 0x7a, 0xe6, 0x68, 0x12, 0x26
> +};
> +enum { nonce01 = 0x3834e2afca3c66d3ULL };
> +
> +static const u8 input02[] __initconst = {
> + 0x9d
> +};
> +static const u8 output02[] __initconst = {
> + 0x94
> +};
> +static const u8 key02[] __initconst = {
> + 0x8c, 0x01, 0xac, 0xaf, 0x62, 0x63, 0x56, 0x7a,
> + 0xad, 0x23, 0x4c, 0x58, 0x29, 0x29, 0xbe, 0xab,
> + 0xe9, 0xf8, 0xdf, 0x6c, 0x8c, 0x74, 0x4d, 0x7d,
> + 0x13, 0x94, 0x10, 0x02, 0x3d, 0x8e, 0x9f, 0x94
> +};
> +enum { nonce02 = 0x5d1b3bfdedd9f73aULL };
> +
> +static const u8 input03[] __initconst = {
> + 0x04, 0x16
> +};
> +static const u8 output03[] __initconst = {
> + 0x92, 0x07
> +};
> +static const u8 key03[] __initconst = {
> + 0x22, 0x0c, 0x79, 0x2c, 0x38, 0x51, 0xbe, 0x99,
> + 0xa9, 0x59, 0x24, 0x50, 0xef, 0x87, 0x38, 0xa6,
> + 0xa0, 0x97, 0x20, 0xcb, 0xb4, 0x0c, 0x94, 0x67,
> + 0x1f, 0x98, 0xdc, 0xc4, 0x83, 0xbc, 0x35, 0x4d
> +};
> +enum { nonce03 = 0x7a3353ad720a3e2eULL };
> +
> +static const u8 input04[] __initconst = {
> + 0xc7, 0xcc, 0xd0
> +};
> +static const u8 output04[] __initconst = {
> + 0xd8, 0x41, 0x80
> +};
> +static const u8 key04[] __initconst = {
> + 0x81, 0x5e, 0x12, 0x01, 0xc4, 0x36, 0x15, 0x03,
> + 0x11, 0xa0, 0xe9, 0x86, 0xbb, 0x5a, 0xdc, 0x45,
> + 0x7d, 0x5e, 0x98, 0xf8, 0x06, 0x76, 0x1c, 0xec,
> + 0xc0, 0xf7, 0xca, 0x4e, 0x99, 0xd9, 0x42, 0x38
> +};
> +enum { nonce04 = 0x6816e2fc66176da2ULL };
> +
> +static const u8 input05[] __initconst = {
> + 0x48, 0xf1, 0x31, 0x5f
> +};
> +static const u8 output05[] __initconst = {
> + 0x48, 0xf7, 0x13, 0x67
> +};
> +static const u8 key05[] __initconst = {
> + 0x3f, 0xd6, 0xb6, 0x5e, 0x2f, 0xda, 0x82, 0x39,
> + 0x97, 0x06, 0xd3, 0x62, 0x4f, 0xbd, 0xcb, 0x9b,
> + 0x1d, 0xe6, 0x4a, 0x76, 0xab, 0xdd, 0x14, 0x50,
> + 0x59, 0x21, 0xe3, 0xb2, 0xc7, 0x95, 0xbc, 0x45
> +};
> +enum { nonce05 = 0xc41a7490e228cc42ULL };
> +
> +static const u8 input06[] __initconst = {
> + 0xae, 0xa2, 0x85, 0x1d, 0xc8
> +};
> +static const u8 output06[] __initconst = {
> + 0xfa, 0xff, 0x45, 0x6b, 0x6f
> +};
> +static const u8 key06[] __initconst = {
> + 0x04, 0x8d, 0xea, 0x67, 0x20, 0x78, 0xfb, 0x8f,
> + 0x49, 0x80, 0x35, 0xb5, 0x7b, 0xe4, 0x31, 0x74,
> + 0x57, 0x43, 0x3a, 0x64, 0x64, 0xb9, 0xe6, 0x23,
> + 0x4d, 0xfe, 0xb8, 0x7b, 0x71, 0x4d, 0x9d, 0x21
> +};
> +enum { nonce06 = 0x251366db50b10903ULL };
> +
> +static const u8 input07[] __initconst = {
> + 0x1a, 0x32, 0x85, 0xb6, 0xe8, 0x52
> +};
> +static const u8 output07[] __initconst = {
> + 0xd3, 0x5f, 0xf0, 0x07, 0x69, 0xec
> +};
> +static const u8 key07[] __initconst = {
> + 0xbf, 0x2d, 0x42, 0x99, 0x97, 0x76, 0x04, 0xad,
> + 0xd3, 0x8f, 0x6e, 0x6a, 0x34, 0x85, 0xaf, 0x81,
> + 0xef, 0x36, 0x33, 0xd5, 0x43, 0xa2, 0xaa, 0x08,
> + 0x0f, 0x77, 0x42, 0x83, 0x58, 0xc5, 0x42, 0x2a
> +};
> +enum { nonce07 = 0xe0796da17dba9b58ULL };
> +
> +static const u8 input08[] __initconst = {
> + 0x40, 0xae, 0xcd, 0xe4, 0x3d, 0x22, 0xe0
> +};
> +static const u8 output08[] __initconst = {
> + 0xfd, 0x8a, 0x9f, 0x3d, 0x05, 0xc9, 0xd3
> +};
> +static const u8 key08[] __initconst = {
> + 0xdc, 0x3f, 0x41, 0xe3, 0x23, 0x2a, 0x8d, 0xf6,
> + 0x41, 0x2a, 0xa7, 0x66, 0x05, 0x68, 0xe4, 0x7b,
> + 0xc4, 0x58, 0xd6, 0xcc, 0xdf, 0x0d, 0xc6, 0x25,
> + 0x1b, 0x61, 0x32, 0x12, 0x4e, 0xf1, 0xe6, 0x29
> +};
> +enum { nonce08 = 0xb1d2536d9e159832ULL };
> +
> +static const u8 input09[] __initconst = {
> + 0xba, 0x1d, 0x14, 0x16, 0x9f, 0x83, 0x67, 0x24
> +};
> +static const u8 output09[] __initconst = {
> + 0x7c, 0xe3, 0x78, 0x1d, 0xa2, 0xe7, 0xe9, 0x39
> +};
> +static const u8 key09[] __initconst = {
> + 0x17, 0x55, 0x90, 0x52, 0xa4, 0xce, 0x12, 0xae,
> + 0xd4, 0xfd, 0xd4, 0xfb, 0xd5, 0x18, 0x59, 0x50,
> + 0x4e, 0x51, 0x99, 0x32, 0x09, 0x31, 0xfc, 0xf7,
> + 0x27, 0x10, 0x8e, 0xa2, 0x4b, 0xa5, 0xf5, 0x62
> +};
> +enum { nonce09 = 0x495fc269536d003ULL };
> +
> +static const u8 input10[] __initconst = {
> + 0x09, 0xfd, 0x3c, 0x0b, 0x3d, 0x0e, 0xf3, 0x9d,
> + 0x27
> +};
> +static const u8 output10[] __initconst = {
> + 0xdc, 0xe4, 0x33, 0x60, 0x0c, 0x07, 0xcb, 0x51,
> + 0x6b
> +};
> +static const u8 key10[] __initconst = {
> + 0x4e, 0x00, 0x72, 0x37, 0x0f, 0x52, 0x4d, 0x6f,
> + 0x37, 0x50, 0x3c, 0xb3, 0x51, 0x81, 0x49, 0x16,
> + 0x7e, 0xfd, 0xb1, 0x51, 0x72, 0x2e, 0xe4, 0x16,
> + 0x68, 0x5c, 0x5b, 0x8a, 0xc3, 0x90, 0x70, 0x04
> +};
> +enum { nonce10 = 0x1ad9d1114d88cbbdULL };
> +
> +static const u8 input11[] __initconst = {
> + 0x70, 0x18, 0x52, 0x85, 0xba, 0x66, 0xff, 0x2c,
> + 0x9a, 0x46
> +};
> +static const u8 output11[] __initconst = {
> + 0xf5, 0x2a, 0x7a, 0xfd, 0x31, 0x7c, 0x91, 0x41,
> + 0xb1, 0xcf
> +};
> +static const u8 key11[] __initconst = {
> + 0x48, 0xb4, 0xd0, 0x7c, 0x88, 0xd1, 0x96, 0x0d,
> + 0x80, 0x33, 0xb4, 0xd5, 0x31, 0x9a, 0x88, 0xca,
> + 0x14, 0xdc, 0xf0, 0xa8, 0xf3, 0xac, 0xb8, 0x47,
> + 0x75, 0x86, 0x7c, 0x88, 0x50, 0x11, 0x43, 0x40
> +};
> +enum { nonce11 = 0x47c35dd1f4f8aa4fULL };
> +
> +static const u8 input12[] __initconst = {
> + 0x9e, 0x8e, 0x3d, 0x2a, 0x05, 0xfd, 0xe4, 0x90,
> + 0x24, 0x1c, 0xd3
> +};
> +static const u8 output12[] __initconst = {
> + 0x97, 0x72, 0x40, 0x9f, 0xc0, 0x6b, 0x05, 0x33,
> + 0x42, 0x7e, 0x28
> +};
> +static const u8 key12[] __initconst = {
> + 0xee, 0xff, 0x33, 0x33, 0xe0, 0x28, 0xdf, 0xa2,
> + 0xb6, 0x5e, 0x25, 0x09, 0x52, 0xde, 0xa5, 0x9c,
> + 0x8f, 0x95, 0xa9, 0x03, 0x77, 0x0f, 0xbe, 0xa1,
> + 0xd0, 0x7d, 0x73, 0x2f, 0xf8, 0x7e, 0x51, 0x44
> +};
> +enum { nonce12 = 0xc22d044dc6ea4af3ULL };
> +
> +static const u8 input13[] __initconst = {
> + 0x9c, 0x16, 0xa2, 0x22, 0x4d, 0xbe, 0x04, 0x9a,
> + 0xb3, 0xb5, 0xc6, 0x58
> +};
> +static const u8 output13[] __initconst = {
> + 0xf0, 0x81, 0xdb, 0x6d, 0xa3, 0xe9, 0xb2, 0xc6,
> + 0x32, 0x50, 0x16, 0x9f
> +};
> +static const u8 key13[] __initconst = {
> + 0x96, 0xb3, 0x01, 0xd2, 0x7a, 0x8c, 0x94, 0x09,
> + 0x4f, 0x58, 0xbe, 0x80, 0xcc, 0xa9, 0x7e, 0x2d,
> + 0xad, 0x58, 0x3b, 0x63, 0xb8, 0x5c, 0x17, 0xce,
> + 0xbf, 0x43, 0x33, 0x7a, 0x7b, 0x82, 0x28, 0x2f
> +};
> +enum { nonce13 = 0x2a5d05d88cd7b0daULL };
> +
> +static const u8 input14[] __initconst = {
> + 0x57, 0x4f, 0xaa, 0x30, 0xe6, 0x23, 0x50, 0x86,
> + 0x91, 0xa5, 0x60, 0x96, 0x2b
> +};
> +static const u8 output14[] __initconst = {
> + 0x6c, 0x1f, 0x3b, 0x42, 0xb6, 0x2f, 0xf0, 0xbd,
> + 0x76, 0x60, 0xc7, 0x7e, 0x8d
> +};
> +static const u8 key14[] __initconst = {
> + 0x22, 0x85, 0xaf, 0x8f, 0xa3, 0x53, 0xa0, 0xc4,
> + 0xb5, 0x75, 0xc0, 0xba, 0x30, 0x92, 0xc3, 0x32,
> + 0x20, 0x5a, 0x8f, 0x7e, 0x93, 0xda, 0x65, 0x18,
> + 0xd1, 0xf6, 0x9a, 0x9b, 0x8f, 0x85, 0x30, 0xe6
> +};
> +enum { nonce14 = 0xf9946c166aa4475fULL };
> +
> +static const u8 input15[] __initconst = {
> + 0x89, 0x81, 0xc7, 0xe2, 0x00, 0xac, 0x52, 0x70,
> + 0xa4, 0x79, 0xab, 0xeb, 0x74, 0xf7
> +};
> +static const u8 output15[] __initconst = {
> + 0xb4, 0xd0, 0xa9, 0x9d, 0x15, 0x5f, 0x48, 0xd6,
> + 0x00, 0x7e, 0x4c, 0x77, 0x5a, 0x46
> +};
> +static const u8 key15[] __initconst = {
> + 0x0a, 0x66, 0x36, 0xca, 0x5d, 0x82, 0x23, 0xb6,
> + 0xe4, 0x9b, 0xad, 0x5e, 0xd0, 0x7f, 0xf6, 0x7a,
> + 0x7b, 0x03, 0xa7, 0x4c, 0xfd, 0xec, 0xd5, 0xa1,
> + 0xfc, 0x25, 0x54, 0xda, 0x5a, 0x5c, 0xf0, 0x2c
> +};
> +enum { nonce15 = 0x9ab2b87a35e772c8ULL };
> +
> +static const u8 input16[] __initconst = {
> + 0x5f, 0x09, 0xc0, 0x8b, 0x1e, 0xde, 0xca, 0xd9,
> + 0xb7, 0x5c, 0x23, 0xc9, 0x55, 0x1e, 0xcf
> +};
> +static const u8 output16[] __initconst = {
> + 0x76, 0x9b, 0x53, 0xf3, 0x66, 0x88, 0x28, 0x60,
> + 0x98, 0x80, 0x2c, 0xa8, 0x80, 0xa6, 0x48
> +};
> +static const u8 key16[] __initconst = {
> + 0x80, 0xb5, 0x51, 0xdf, 0x17, 0x5b, 0xb0, 0xef,
> + 0x8b, 0x5b, 0x2e, 0x3e, 0xc5, 0xe3, 0xa5, 0x86,
> + 0xac, 0x0d, 0x8e, 0x32, 0x90, 0x9d, 0x82, 0x27,
> + 0xf1, 0x23, 0x26, 0xc3, 0xea, 0x55, 0xb6, 0x63
> +};
> +enum { nonce16 = 0xa82e9d39e4d02ef5ULL };
> +
> +static const u8 input17[] __initconst = {
> + 0x87, 0x0b, 0x36, 0x71, 0x7c, 0xb9, 0x0b, 0x80,
> + 0x4d, 0x77, 0x5c, 0x4f, 0xf5, 0x51, 0x0e, 0x1a
> +};
> +static const u8 output17[] __initconst = {
> + 0xf1, 0x12, 0x4a, 0x8a, 0xd9, 0xd0, 0x08, 0x67,
> + 0x66, 0xd7, 0x34, 0xea, 0x32, 0x3b, 0x54, 0x0e
> +};
> +static const u8 key17[] __initconst = {
> + 0xfb, 0x71, 0x5f, 0x3f, 0x7a, 0xc0, 0x9a, 0xc8,
> + 0xc8, 0xcf, 0xe8, 0xbc, 0xfb, 0x09, 0xbf, 0x89,
> + 0x6a, 0xef, 0xd5, 0xe5, 0x36, 0x87, 0x14, 0x76,
> + 0x00, 0xb9, 0x32, 0x28, 0xb2, 0x00, 0x42, 0x53
> +};
> +enum { nonce17 = 0x229b87e73d557b96ULL };
> +
> +static const u8 input18[] __initconst = {
> + 0x38, 0x42, 0xb5, 0x37, 0xb4, 0x3d, 0xfe, 0x59,
> + 0x38, 0x68, 0x88, 0xfa, 0x89, 0x8a, 0x5f, 0x90,
> + 0x3c
> +};
> +static const u8 output18[] __initconst = {
> + 0xac, 0xad, 0x14, 0xe8, 0x7e, 0xd7, 0xce, 0x96,
> + 0x3d, 0xb3, 0x78, 0x85, 0x22, 0x5a, 0xcb, 0x39,
> + 0xd4
> +};
> +static const u8 key18[] __initconst = {
> + 0xe1, 0xc1, 0xa8, 0xe0, 0x91, 0xe7, 0x38, 0x66,
> + 0x80, 0x17, 0x12, 0x3c, 0x5e, 0x2d, 0xbb, 0xea,
> + 0xeb, 0x6c, 0x8b, 0xc8, 0x1b, 0x6f, 0x7c, 0xea,
> + 0x50, 0x57, 0x23, 0x1e, 0x65, 0x6f, 0x6d, 0x81
> +};
> +enum { nonce18 = 0xfaf5fcf8f30e57a9ULL };
> +
> +static const u8 input19[] __initconst = {
> + 0x1c, 0x4a, 0x30, 0x26, 0xef, 0x9a, 0x32, 0xa7,
> + 0x8f, 0xe5, 0xc0, 0x0f, 0x30, 0x3a, 0xbf, 0x38,
> + 0x54, 0xba
> +};
> +static const u8 output19[] __initconst = {
> + 0x57, 0x67, 0x54, 0x4f, 0x31, 0xd6, 0xef, 0x35,
> + 0x0b, 0xd9, 0x52, 0xa7, 0x46, 0x7d, 0x12, 0x17,
> + 0x1e, 0xe3
> +};
> +static const u8 key19[] __initconst = {
> + 0x5a, 0x79, 0xc1, 0xea, 0x33, 0xb3, 0xc7, 0x21,
> + 0xec, 0xf8, 0xcb, 0xd2, 0x58, 0x96, 0x23, 0xd6,
> + 0x4d, 0xed, 0x2f, 0xdf, 0x8a, 0x79, 0xe6, 0x8b,
> + 0x38, 0xa3, 0xc3, 0x7a, 0x33, 0xda, 0x02, 0xc7
> +};
> +enum { nonce19 = 0x2b23b61840429604ULL };
> +
> +static const u8 input20[] __initconst = {
> + 0xab, 0xe9, 0x32, 0xbb, 0x35, 0x17, 0xe0, 0x60,
> + 0x80, 0xb1, 0x27, 0xdc, 0xe6, 0x62, 0x9e, 0x0c,
> + 0x77, 0xf4, 0x50
> +};
> +static const u8 output20[] __initconst = {
> + 0x54, 0x6d, 0xaa, 0xfc, 0x08, 0xfb, 0x71, 0xa8,
> + 0xd6, 0x1d, 0x7d, 0xf3, 0x45, 0x10, 0xb5, 0x4c,
> + 0xcc, 0x4b, 0x45
> +};
> +static const u8 key20[] __initconst = {
> + 0xa3, 0xfd, 0x3d, 0xa9, 0xeb, 0xea, 0x2c, 0x69,
> + 0xcf, 0x59, 0x38, 0x13, 0x5b, 0xa7, 0x53, 0x8f,
> + 0x5e, 0xa2, 0x33, 0x86, 0x4c, 0x75, 0x26, 0xaf,
> + 0x35, 0x12, 0x09, 0x71, 0x81, 0xea, 0x88, 0x66
> +};
> +enum { nonce20 = 0x7459667a8fadff58ULL };
> +
> +static const u8 input21[] __initconst = {
> + 0xa6, 0x82, 0x21, 0x23, 0xad, 0x27, 0x3f, 0xc6,
> + 0xd7, 0x16, 0x0d, 0x6d, 0x24, 0x15, 0x54, 0xc5,
> + 0x96, 0x72, 0x59, 0x8a
> +};
> +static const u8 output21[] __initconst = {
> + 0x5f, 0x34, 0x32, 0xea, 0x06, 0xd4, 0x9e, 0x01,
> + 0xdc, 0x32, 0x32, 0x40, 0x66, 0x73, 0x6d, 0x4a,
> + 0x6b, 0x12, 0x20, 0xe8
> +};
> +static const u8 key21[] __initconst = {
> + 0x96, 0xfd, 0x13, 0x23, 0xa9, 0x89, 0x04, 0xe6,
> + 0x31, 0xa5, 0x2c, 0xc1, 0x40, 0xd5, 0x69, 0x5c,
> + 0x32, 0x79, 0x56, 0xe0, 0x29, 0x93, 0x8f, 0xe8,
> + 0x5f, 0x65, 0x53, 0x7f, 0xc1, 0xe9, 0xaf, 0xaf
> +};
> +enum { nonce21 = 0xba8defee9d8e13b5ULL };
> +
> +static const u8 input22[] __initconst = {
> + 0xb8, 0x32, 0x1a, 0x81, 0xd8, 0x38, 0x89, 0x5a,
> + 0xb0, 0x05, 0xbe, 0xf4, 0xd2, 0x08, 0xc6, 0xee,
> + 0x79, 0x7b, 0x3a, 0x76, 0x59
> +};
> +static const u8 output22[] __initconst = {
> + 0xb7, 0xba, 0xae, 0x80, 0xe4, 0x9f, 0x79, 0x84,
> + 0x5a, 0x48, 0x50, 0x6d, 0xcb, 0xd0, 0x06, 0x0c,
> + 0x15, 0x63, 0xa7, 0x5e, 0xbd
> +};
> +static const u8 key22[] __initconst = {
> + 0x0f, 0x35, 0x3d, 0xeb, 0x5f, 0x0a, 0x82, 0x0d,
> + 0x24, 0x59, 0x71, 0xd8, 0xe6, 0x2d, 0x5f, 0xe1,
> + 0x7e, 0x0c, 0xae, 0xf6, 0xdc, 0x2c, 0xc5, 0x4a,
> + 0x38, 0x88, 0xf2, 0xde, 0xd9, 0x5f, 0x76, 0x7c
> +};
> +enum { nonce22 = 0xe77f1760e9f5e192ULL };
> +
> +static const u8 input23[] __initconst = {
> + 0x4b, 0x1e, 0x79, 0x99, 0xcf, 0xef, 0x64, 0x4b,
> + 0xb0, 0x66, 0xae, 0x99, 0x2e, 0x68, 0x97, 0xf5,
> + 0x5d, 0x9b, 0x3f, 0x7a, 0xa9, 0xd9
> +};
> +static const u8 output23[] __initconst = {
> + 0x5f, 0xa4, 0x08, 0x39, 0xca, 0xfa, 0x2b, 0x83,
> + 0x5d, 0x95, 0x70, 0x7c, 0x2e, 0xd4, 0xae, 0xfa,
> + 0x45, 0x4a, 0x77, 0x7f, 0xa7, 0x65
> +};
> +static const u8 key23[] __initconst = {
> + 0x4a, 0x06, 0x83, 0x64, 0xaa, 0xe3, 0x38, 0x32,
> + 0x28, 0x5d, 0xa4, 0xb2, 0x5a, 0xee, 0xcf, 0x8e,
> + 0x19, 0x67, 0xf1, 0x09, 0xe8, 0xc9, 0xf6, 0x40,
> + 0x02, 0x6d, 0x0b, 0xde, 0xfa, 0x81, 0x03, 0xb1
> +};
> +enum { nonce23 = 0x9b3f349158709849ULL };
> +
> +static const u8 input24[] __initconst = {
> + 0xc6, 0xfc, 0x47, 0x5e, 0xd8, 0xed, 0xa9, 0xe5,
> + 0x4f, 0x82, 0x79, 0x35, 0xee, 0x3e, 0x7e, 0x3e,
> + 0x35, 0x70, 0x6e, 0xfa, 0x6d, 0x08, 0xe8
> +};
> +static const u8 output24[] __initconst = {
> + 0x3b, 0xc5, 0xf8, 0xc2, 0xbf, 0x2b, 0x90, 0x33,
> + 0xa6, 0xae, 0xf5, 0x5a, 0x65, 0xb3, 0x3d, 0xe1,
> + 0xcd, 0x5f, 0x55, 0xfa, 0xe7, 0xa5, 0x4a
> +};
> +static const u8 key24[] __initconst = {
> + 0x00, 0x24, 0xc3, 0x65, 0x5f, 0xe6, 0x31, 0xbb,
> + 0x6d, 0xfc, 0x20, 0x7b, 0x1b, 0xa8, 0x96, 0x26,
> + 0x55, 0x21, 0x62, 0x25, 0x7e, 0xba, 0x23, 0x97,
> + 0xc9, 0xb8, 0x53, 0xa8, 0xef, 0xab, 0xad, 0x61
> +};
> +enum { nonce24 = 0x13ee0b8f526177c3ULL };
> +
> +static const u8 input25[] __initconst = {
> + 0x33, 0x07, 0x16, 0xb1, 0x34, 0x33, 0x67, 0x04,
> + 0x9b, 0x0a, 0xce, 0x1b, 0xe9, 0xde, 0x1a, 0xec,
> + 0xd0, 0x55, 0xfb, 0xc6, 0x33, 0xaf, 0x2d, 0xe3
> +};
> +static const u8 output25[] __initconst = {
> + 0x05, 0x93, 0x10, 0xd1, 0x58, 0x6f, 0x68, 0x62,
> + 0x45, 0xdb, 0x91, 0xae, 0x70, 0xcf, 0xd4, 0x5f,
> + 0xee, 0xdf, 0xd5, 0xba, 0x9e, 0xde, 0x68, 0xe6
> +};
> +static const u8 key25[] __initconst = {
> + 0x83, 0xa9, 0x4f, 0x5d, 0x74, 0xd5, 0x91, 0xb3,
> + 0xc9, 0x97, 0x19, 0x15, 0xdb, 0x0d, 0x0b, 0x4a,
> + 0x3d, 0x55, 0xcf, 0xab, 0xb2, 0x05, 0x21, 0x35,
> + 0x45, 0x50, 0xeb, 0xf8, 0xf5, 0xbf, 0x36, 0x35
> +};
> +enum { nonce25 = 0x7c6f459e49ebfebcULL };
> +
> +static const u8 input26[] __initconst = {
> + 0xc2, 0xd4, 0x7a, 0xa3, 0x92, 0xe1, 0xac, 0x46,
> + 0x1a, 0x15, 0x38, 0xc9, 0xb5, 0xfd, 0xdf, 0x84,
> + 0x38, 0xbc, 0x6b, 0x1d, 0xb0, 0x83, 0x43, 0x04,
> + 0x39
> +};
> +static const u8 output26[] __initconst = {
> + 0x7f, 0xde, 0xd6, 0x87, 0xcc, 0x34, 0xf4, 0x12,
> + 0xae, 0x55, 0xa5, 0x89, 0x95, 0x29, 0xfc, 0x18,
> + 0xd8, 0xc7, 0x7c, 0xd3, 0xcb, 0x85, 0x95, 0x21,
> + 0xd2
> +};
> +static const u8 key26[] __initconst = {
> + 0xe4, 0xd0, 0x54, 0x1d, 0x7d, 0x47, 0xa8, 0xc1,
> + 0x08, 0xca, 0xe2, 0x42, 0x52, 0x95, 0x16, 0x43,
> + 0xa3, 0x01, 0x23, 0x03, 0xcc, 0x3b, 0x81, 0x78,
> + 0x23, 0xcc, 0xa7, 0x36, 0xd7, 0xa0, 0x97, 0x8d
> +};
> +enum { nonce26 = 0x524401012231683ULL };
> +
> +static const u8 input27[] __initconst = {
> + 0x0d, 0xb0, 0xcf, 0xec, 0xfc, 0x38, 0x9d, 0x9d,
> + 0x89, 0x00, 0x96, 0xf2, 0x79, 0x8a, 0xa1, 0x8d,
> + 0x32, 0x5e, 0xc6, 0x12, 0x22, 0xec, 0xf6, 0x52,
> + 0xc1, 0x0b
> +};
> +static const u8 output27[] __initconst = {
> + 0xef, 0xe1, 0xf2, 0x67, 0x8e, 0x2c, 0x00, 0x9f,
> + 0x1d, 0x4c, 0x66, 0x1f, 0x94, 0x58, 0xdc, 0xbb,
> + 0xb9, 0x11, 0x8f, 0x74, 0xfd, 0x0e, 0x14, 0x01,
> + 0xa8, 0x21
> +};
> +static const u8 key27[] __initconst = {
> + 0x78, 0x71, 0xa4, 0xe6, 0xb2, 0x95, 0x44, 0x12,
> + 0x81, 0xaa, 0x7e, 0x94, 0xa7, 0x8d, 0x44, 0xea,
> + 0xc4, 0xbc, 0x01, 0xb7, 0x9e, 0xf7, 0x82, 0x9e,
> + 0x3b, 0x23, 0x9f, 0x31, 0xdd, 0xb8, 0x0d, 0x18
> +};
> +enum { nonce27 = 0xd58fe0e58fb254d6ULL };
> +
> +static const u8 input28[] __initconst = {
> + 0xaa, 0xb7, 0xaa, 0xd9, 0xa8, 0x91, 0xd7, 0x8a,
> + 0x97, 0x9b, 0xdb, 0x7c, 0x47, 0x2b, 0xdb, 0xd2,
> + 0xda, 0x77, 0xb1, 0xfa, 0x2d, 0x12, 0xe3, 0xe9,
> + 0xc4, 0x7f, 0x54
> +};
> +static const u8 output28[] __initconst = {
> + 0x87, 0x84, 0xa9, 0xa6, 0xad, 0x8f, 0xe6, 0x0f,
> + 0x69, 0xf8, 0x21, 0xc3, 0x54, 0x95, 0x0f, 0xb0,
> + 0x4e, 0xc7, 0x02, 0xe4, 0x04, 0xb0, 0x6c, 0x42,
> + 0x8c, 0x63, 0xe3
> +};
> +static const u8 key28[] __initconst = {
> + 0x12, 0x23, 0x37, 0x95, 0x04, 0xb4, 0x21, 0xe8,
> + 0xbc, 0x65, 0x46, 0x7a, 0xf4, 0x01, 0x05, 0x3f,
> + 0xb1, 0x34, 0x73, 0xd2, 0x49, 0xbf, 0x6f, 0x20,
> + 0xbd, 0x23, 0x58, 0x5f, 0xd1, 0x73, 0x57, 0xa6
> +};
> +enum { nonce28 = 0x3a04d51491eb4e07ULL };
> +
> +static const u8 input29[] __initconst = {
> + 0x55, 0xd0, 0xd4, 0x4b, 0x17, 0xc8, 0xc4, 0x2b,
> + 0xc0, 0x28, 0xbd, 0x9d, 0x65, 0x4d, 0xaf, 0x77,
> + 0x72, 0x7c, 0x36, 0x68, 0xa7, 0xb6, 0x87, 0x4d,
> + 0xb9, 0x27, 0x25, 0x6c
> +};
> +static const u8 output29[] __initconst = {
> + 0x0e, 0xac, 0x4c, 0xf5, 0x12, 0xb5, 0x56, 0xa5,
> + 0x00, 0x9a, 0xd6, 0xe5, 0x1a, 0x59, 0x2c, 0xf6,
> + 0x42, 0x22, 0xcf, 0x23, 0x98, 0x34, 0x29, 0xac,
> + 0x6e, 0xe3, 0x37, 0x6d
> +};
> +static const u8 key29[] __initconst = {
> + 0xda, 0x9d, 0x05, 0x0c, 0x0c, 0xba, 0x75, 0xb9,
> + 0x9e, 0xb1, 0x8d, 0xd9, 0x73, 0x26, 0x2c, 0xa9,
> + 0x3a, 0xb5, 0xcb, 0x19, 0x49, 0xa7, 0x4f, 0xf7,
> + 0x64, 0x35, 0x23, 0x20, 0x2a, 0x45, 0x78, 0xc7
> +};
> +enum { nonce29 = 0xc25ac9982431cbfULL };
> +
> +static const u8 input30[] __initconst = {
> + 0x4e, 0xd6, 0x85, 0xbb, 0xe7, 0x99, 0xfa, 0x04,
> + 0x33, 0x24, 0xfd, 0x75, 0x18, 0xe3, 0xd3, 0x25,
> + 0xcd, 0xca, 0xae, 0x00, 0xbe, 0x52, 0x56, 0x4a,
> + 0x31, 0xe9, 0x4f, 0xae, 0x8a
> +};
> +static const u8 output30[] __initconst = {
> + 0x30, 0x36, 0x32, 0xa2, 0x3c, 0xb6, 0xf9, 0xf9,
> + 0x76, 0x70, 0xad, 0xa6, 0x10, 0x41, 0x00, 0x4a,
> + 0xfa, 0xce, 0x1b, 0x86, 0x05, 0xdb, 0x77, 0x96,
> + 0xb3, 0xb7, 0x8f, 0x61, 0x24
> +};
> +static const u8 key30[] __initconst = {
> + 0x49, 0x35, 0x4c, 0x15, 0x98, 0xfb, 0xc6, 0x57,
> + 0x62, 0x6d, 0x06, 0xc3, 0xd4, 0x79, 0x20, 0x96,
> + 0x05, 0x2a, 0x31, 0x63, 0xc0, 0x44, 0x42, 0x09,
> + 0x13, 0x13, 0xff, 0x1b, 0xc8, 0x63, 0x1f, 0x0b
> +};
> +enum { nonce30 = 0x4967f9c08e41568bULL };
> +
> +static const u8 input31[] __initconst = {
> + 0x91, 0x04, 0x20, 0x47, 0x59, 0xee, 0xa6, 0x0f,
> + 0x04, 0x75, 0xc8, 0x18, 0x95, 0x44, 0x01, 0x28,
> + 0x20, 0x6f, 0x73, 0x68, 0x66, 0xb5, 0x03, 0xb3,
> + 0x58, 0x27, 0x6e, 0x7a, 0x76, 0xb8
> +};
> +static const u8 output31[] __initconst = {
> + 0xe8, 0x03, 0x78, 0x9d, 0x13, 0x15, 0x98, 0xef,
> + 0x64, 0x68, 0x12, 0x41, 0xb0, 0x29, 0x94, 0x0c,
> + 0x83, 0x35, 0x46, 0xa9, 0x74, 0xe1, 0x75, 0xf0,
> + 0xb6, 0x96, 0xc3, 0x6f, 0xd7, 0x70
> +};
> +static const u8 key31[] __initconst = {
> + 0xef, 0xcd, 0x5a, 0x4a, 0xf4, 0x7e, 0x6a, 0x3a,
> + 0x11, 0x88, 0x72, 0x94, 0xb8, 0xae, 0x84, 0xc3,
> + 0x66, 0xe0, 0xde, 0x4b, 0x00, 0xa5, 0xd6, 0x2d,
> + 0x50, 0xb7, 0x28, 0xff, 0x76, 0x57, 0x18, 0x1f
> +};
> +enum { nonce31 = 0xcb6f428fa4192e19ULL };
> +
> +static const u8 input32[] __initconst = {
> + 0x90, 0x06, 0x50, 0x4b, 0x98, 0x14, 0x30, 0xf1,
> + 0xb8, 0xd7, 0xf0, 0xa4, 0x3e, 0x4e, 0xd8, 0x00,
> + 0xea, 0xdb, 0x4f, 0x93, 0x05, 0xef, 0x02, 0x71,
> + 0x1a, 0xcd, 0xa3, 0xb1, 0xae, 0xd3, 0x18
> +};
> +static const u8 output32[] __initconst = {
> + 0xcb, 0x4a, 0x37, 0x3f, 0xea, 0x40, 0xab, 0x86,
> + 0xfe, 0xcc, 0x07, 0xd5, 0xdc, 0xb2, 0x25, 0xb6,
> + 0xfd, 0x2a, 0x72, 0xbc, 0x5e, 0xd4, 0x75, 0xff,
> + 0x71, 0xfc, 0xce, 0x1e, 0x6f, 0x22, 0xc1
> +};
> +static const u8 key32[] __initconst = {
> + 0xfc, 0x6d, 0xc3, 0x80, 0xce, 0xa4, 0x31, 0xa1,
> + 0xcc, 0xfa, 0x9d, 0x10, 0x0b, 0xc9, 0x11, 0x77,
> + 0x34, 0xdb, 0xad, 0x1b, 0xc4, 0xfc, 0xeb, 0x79,
> + 0x91, 0xda, 0x59, 0x3b, 0x0d, 0xb1, 0x19, 0x3b
> +};
> +enum { nonce32 = 0x88551bf050059467ULL };
> +
> +static const u8 input33[] __initconst = {
> + 0x88, 0x94, 0x71, 0x92, 0xe8, 0xd7, 0xf9, 0xbd,
> + 0x55, 0xe3, 0x22, 0xdb, 0x99, 0x51, 0xfb, 0x50,
> + 0xbf, 0x82, 0xb5, 0x70, 0x8b, 0x2b, 0x6a, 0x03,
> + 0x37, 0xa0, 0xc6, 0x19, 0x5d, 0xc9, 0xbc, 0xcc
> +};
> +static const u8 output33[] __initconst = {
> + 0xb6, 0x17, 0x51, 0xc8, 0xea, 0x8a, 0x14, 0xdc,
> + 0x23, 0x1b, 0xd4, 0xed, 0xbf, 0x50, 0xb9, 0x38,
> + 0x00, 0xc2, 0x3f, 0x78, 0x3d, 0xbf, 0xa0, 0x84,
> + 0xef, 0x45, 0xb2, 0x7d, 0x48, 0x7b, 0x62, 0xa7
> +};
> +static const u8 key33[] __initconst = {
> + 0xb9, 0x8f, 0x6a, 0xad, 0xb4, 0x6f, 0xb5, 0xdc,
> + 0x48, 0xfa, 0x43, 0x57, 0x62, 0x97, 0xef, 0x89,
> + 0x4c, 0x5a, 0x7b, 0x67, 0xb8, 0x9d, 0xf0, 0x42,
> + 0x2b, 0x8f, 0xf3, 0x18, 0x05, 0x2e, 0x48, 0xd0
> +};
> +enum { nonce33 = 0x31f16488fe8447f5ULL };
> +
> +static const u8 input34[] __initconst = {
> + 0xda, 0x2b, 0x3d, 0x63, 0x9e, 0x4f, 0xc2, 0xb8,
> + 0x7f, 0xc2, 0x1a, 0x8b, 0x0d, 0x95, 0x65, 0x55,
> + 0x52, 0xba, 0x51, 0x51, 0xc0, 0x61, 0x9f, 0x0a,
> + 0x5d, 0xb0, 0x59, 0x8c, 0x64, 0x6a, 0xab, 0xf5,
> + 0x57
> +};
> +static const u8 output34[] __initconst = {
> + 0x5c, 0xf6, 0x62, 0x24, 0x8c, 0x45, 0xa3, 0x26,
> + 0xd0, 0xe4, 0x88, 0x1c, 0xed, 0xc4, 0x26, 0x58,
> + 0xb5, 0x5d, 0x92, 0xc4, 0x17, 0x44, 0x1c, 0xb8,
> + 0x2c, 0xf3, 0x55, 0x7e, 0xd6, 0xe5, 0xb3, 0x65,
> + 0xa8
> +};
> +static const u8 key34[] __initconst = {
> + 0xde, 0xd1, 0x27, 0xb7, 0x7c, 0xfa, 0xa6, 0x78,
> + 0x39, 0x80, 0xdf, 0xb7, 0x46, 0xac, 0x71, 0x26,
> + 0xd0, 0x2a, 0x56, 0x79, 0x12, 0xeb, 0x26, 0x37,
> + 0x01, 0x0d, 0x30, 0xe0, 0xe3, 0x66, 0xb2, 0xf4
> +};
> +enum { nonce34 = 0x92d0d9b252c24149ULL };
> +
> +static const u8 input35[] __initconst = {
> + 0x3a, 0x15, 0x5b, 0x75, 0x6e, 0xd0, 0x52, 0x20,
> + 0x6c, 0x82, 0xfa, 0xce, 0x5b, 0xea, 0xf5, 0x43,
> + 0xc1, 0x81, 0x7c, 0xb2, 0xac, 0x16, 0x3f, 0xd3,
> + 0x5a, 0xaf, 0x55, 0x98, 0xf4, 0xc6, 0xba, 0x71,
> + 0x25, 0x8b
> +};
> +static const u8 output35[] __initconst = {
> + 0xb3, 0xaf, 0xac, 0x6d, 0x4d, 0xc7, 0x68, 0x56,
> + 0x50, 0x5b, 0x69, 0x2a, 0xe5, 0x90, 0xf9, 0x5f,
> + 0x99, 0x88, 0xff, 0x0c, 0xa6, 0xb1, 0x83, 0xd6,
> + 0x80, 0xa6, 0x1b, 0xde, 0x94, 0xa4, 0x2c, 0xc3,
> + 0x74, 0xfa
> +};
> +static const u8 key35[] __initconst = {
> + 0xd8, 0x24, 0xe2, 0x06, 0xd7, 0x7a, 0xce, 0x81,
> + 0x52, 0x72, 0x02, 0x69, 0x89, 0xc4, 0xe9, 0x53,
> + 0x3b, 0x08, 0x5f, 0x98, 0x1e, 0x1b, 0x99, 0x6e,
> + 0x28, 0x17, 0x6d, 0xba, 0xc0, 0x96, 0xf9, 0x3c
> +};
> +enum { nonce35 = 0x7baf968c4c8e3a37ULL };
> +
> +static const u8 input36[] __initconst = {
> + 0x31, 0x5d, 0x4f, 0xe3, 0xac, 0xad, 0x17, 0xa6,
> + 0xb5, 0x01, 0xe2, 0xc6, 0xd4, 0x7e, 0xc4, 0x80,
> + 0xc0, 0x59, 0x72, 0xbb, 0x4b, 0x74, 0x6a, 0x41,
> + 0x0f, 0x9c, 0xf6, 0xca, 0x20, 0xb3, 0x73, 0x07,
> + 0x6b, 0x02, 0x2a
> +};
> +static const u8 output36[] __initconst = {
> + 0xf9, 0x09, 0x92, 0x94, 0x7e, 0x31, 0xf7, 0x53,
> + 0xe8, 0x8a, 0x5b, 0x20, 0xef, 0x9b, 0x45, 0x81,
> + 0xba, 0x5e, 0x45, 0x63, 0xc1, 0xc7, 0x9e, 0x06,
> + 0x0e, 0xd9, 0x62, 0x8e, 0x96, 0xf9, 0xfa, 0x43,
> + 0x4d, 0xd4, 0x28
> +};
> +static const u8 key36[] __initconst = {
> + 0x13, 0x30, 0x4c, 0x06, 0xae, 0x18, 0xde, 0x03,
> + 0x1d, 0x02, 0x40, 0xf5, 0xbb, 0x19, 0xe3, 0x88,
> + 0x41, 0xb1, 0x29, 0x15, 0x97, 0xc2, 0x69, 0x3f,
> + 0x32, 0x2a, 0x0c, 0x8b, 0xcf, 0x83, 0x8b, 0x6c
> +};
> +enum { nonce36 = 0x226d251d475075a0ULL };
> +
> +static const u8 input37[] __initconst = {
> + 0x10, 0x18, 0xbe, 0xfd, 0x66, 0xc9, 0x77, 0xcc,
> + 0x43, 0xe5, 0x46, 0x0b, 0x08, 0x8b, 0xae, 0x11,
> + 0x86, 0x15, 0xc2, 0xf6, 0x45, 0xd4, 0x5f, 0xd6,
> + 0xb6, 0x5f, 0x9f, 0x3e, 0x97, 0xb7, 0xd4, 0xad,
> + 0x0b, 0xe8, 0x31, 0x94
> +};
> +static const u8 output37[] __initconst = {
> + 0x03, 0x2c, 0x1c, 0xee, 0xc6, 0xdd, 0xed, 0x38,
> + 0x80, 0x6d, 0x84, 0x16, 0xc3, 0xc2, 0x04, 0x63,
> + 0xcd, 0xa7, 0x6e, 0x36, 0x8b, 0xed, 0x78, 0x63,
> + 0x95, 0xfc, 0x69, 0x7a, 0x3f, 0x8d, 0x75, 0x6b,
> + 0x6c, 0x26, 0x56, 0x4d
> +};
> +static const u8 key37[] __initconst = {
> + 0xac, 0x84, 0x4d, 0xa9, 0x29, 0x49, 0x3c, 0x39,
> + 0x7f, 0xd9, 0xa6, 0x01, 0xf3, 0x7e, 0xfa, 0x4a,
> + 0x14, 0x80, 0x22, 0x74, 0xf0, 0x29, 0x30, 0x2d,
> + 0x07, 0x21, 0xda, 0xc0, 0x4d, 0x70, 0x56, 0xa2
> +};
> +enum { nonce37 = 0x167823ce3b64925aULL };
> +
> +static const u8 input38[] __initconst = {
> + 0x30, 0x8f, 0xfa, 0x24, 0x29, 0xb1, 0xfb, 0xce,
> + 0x31, 0x62, 0xdc, 0xd0, 0x46, 0xab, 0xe1, 0x31,
> + 0xd9, 0xae, 0x60, 0x0d, 0xca, 0x0a, 0x49, 0x12,
> + 0x3d, 0x92, 0xe9, 0x91, 0x67, 0x12, 0x62, 0x18,
> + 0x89, 0xe2, 0xf9, 0x1c, 0xcc
> +};
> +static const u8 output38[] __initconst = {
> + 0x56, 0x9c, 0xc8, 0x7a, 0xc5, 0x98, 0xa3, 0x0f,
> + 0xba, 0xd5, 0x3e, 0xe1, 0xc9, 0x33, 0x64, 0x33,
> + 0xf0, 0xd5, 0xf7, 0x43, 0x66, 0x0e, 0x08, 0x9a,
> + 0x6e, 0x09, 0xe4, 0x01, 0x0d, 0x1e, 0x2f, 0x4b,
> + 0xed, 0x9c, 0x08, 0x8c, 0x03
> +};
> +static const u8 key38[] __initconst = {
> + 0x77, 0x52, 0x2a, 0x23, 0xf1, 0xc5, 0x96, 0x2b,
> + 0x89, 0x4f, 0x3e, 0xf3, 0xff, 0x0e, 0x94, 0xce,
> + 0xf1, 0xbd, 0x53, 0xf5, 0x77, 0xd6, 0x9e, 0x47,
> + 0x49, 0x3d, 0x16, 0x64, 0xff, 0x95, 0x42, 0x42
> +};
> +enum { nonce38 = 0xff629d7b82cef357ULL };
> +
> +static const u8 input39[] __initconst = {
> + 0x38, 0x26, 0x27, 0xd0, 0xc2, 0xf5, 0x34, 0xba,
> + 0xda, 0x0f, 0x1c, 0x1c, 0x9a, 0x70, 0xe5, 0x8a,
> + 0x78, 0x2d, 0x8f, 0x9a, 0xbf, 0x89, 0x6a, 0xfd,
> + 0xd4, 0x9c, 0x33, 0xf1, 0xb6, 0x89, 0x16, 0xe3,
> + 0x6a, 0x00, 0xfa, 0x3a, 0x0f, 0x26
> +};
> +static const u8 output39[] __initconst = {
> + 0x0f, 0xaf, 0x91, 0x6d, 0x9c, 0x99, 0xa4, 0xf7,
> + 0x3b, 0x9d, 0x9a, 0x98, 0xca, 0xbb, 0x50, 0x48,
> + 0xee, 0xcb, 0x5d, 0xa1, 0x37, 0x2d, 0x36, 0x09,
> + 0x2a, 0xe2, 0x1c, 0x3d, 0x98, 0x40, 0x1c, 0x16,
> + 0x56, 0xa7, 0x98, 0xe9, 0x7d, 0x2b
> +};
> +static const u8 key39[] __initconst = {
> + 0x6e, 0x83, 0x15, 0x4d, 0xf8, 0x78, 0xa8, 0x0e,
> + 0x71, 0x37, 0xd4, 0x6e, 0x28, 0x5c, 0x06, 0xa1,
> + 0x2d, 0x6c, 0x72, 0x7a, 0xfd, 0xf8, 0x65, 0x1a,
> + 0xb8, 0xe6, 0x29, 0x7b, 0xe5, 0xb3, 0x23, 0x79
> +};
> +enum { nonce39 = 0xa4d8c491cf093e9dULL };
> +
> +static const u8 input40[] __initconst = {
> + 0x8f, 0x32, 0x7c, 0x40, 0x37, 0x95, 0x08, 0x00,
> + 0x00, 0xfe, 0x2f, 0x95, 0x20, 0x12, 0x40, 0x18,
> + 0x5e, 0x7e, 0x5e, 0x99, 0xee, 0x8d, 0x91, 0x7d,
> + 0x50, 0x7d, 0x21, 0x45, 0x27, 0xe1, 0x7f, 0xd4,
> + 0x73, 0x10, 0xe1, 0x33, 0xbc, 0xf8, 0xdd
> +};
> +static const u8 output40[] __initconst = {
> + 0x78, 0x7c, 0xdc, 0x55, 0x2b, 0xd9, 0x2b, 0x3a,
> + 0xdd, 0x56, 0x11, 0x52, 0xd3, 0x2e, 0xe0, 0x0d,
> + 0x23, 0x20, 0x8a, 0xf1, 0x4f, 0xee, 0xf1, 0x68,
> + 0xf6, 0xdc, 0x53, 0xcf, 0x17, 0xd4, 0xf0, 0x6c,
> + 0xdc, 0x80, 0x5f, 0x1c, 0xa4, 0x91, 0x05
> +};
> +static const u8 key40[] __initconst = {
> + 0x0d, 0x86, 0xbf, 0x8a, 0xba, 0x9e, 0x39, 0x91,
> + 0xa8, 0xe7, 0x22, 0xf0, 0x0c, 0x43, 0x18, 0xe4,
> + 0x1f, 0xb0, 0xaf, 0x8a, 0x34, 0x31, 0xf4, 0x41,
> + 0xf0, 0x89, 0x85, 0xca, 0x5d, 0x05, 0x3b, 0x94
> +};
> +enum { nonce40 = 0xae7acc4f5986439eULL };
> +
> +static const u8 input41[] __initconst = {
> + 0x20, 0x5f, 0xc1, 0x83, 0x36, 0x02, 0x76, 0x96,
> + 0xf0, 0xbf, 0x8e, 0x0e, 0x1a, 0xd1, 0xc7, 0x88,
> + 0x18, 0xc7, 0x09, 0xc4, 0x15, 0xd9, 0x4f, 0x5e,
> + 0x1f, 0xb3, 0xb4, 0x6d, 0xcb, 0xa0, 0xd6, 0x8a,
> + 0x3b, 0x40, 0x8e, 0x80, 0xf1, 0xe8, 0x8f, 0x5f
> +};
> +static const u8 output41[] __initconst = {
> + 0x0b, 0xd1, 0x49, 0x9a, 0x9d, 0xe8, 0x97, 0xb8,
> + 0xd1, 0xeb, 0x90, 0x62, 0x37, 0xd2, 0x99, 0x15,
> + 0x67, 0x6d, 0x27, 0x93, 0xce, 0x37, 0x65, 0xa2,
> + 0x94, 0x88, 0xd6, 0x17, 0xbc, 0x1c, 0x6e, 0xa2,
> + 0xcc, 0xfb, 0x81, 0x0e, 0x30, 0x60, 0x5a, 0x6f
> +};
> +static const u8 key41[] __initconst = {
> + 0x36, 0x27, 0x57, 0x01, 0x21, 0x68, 0x97, 0xc7,
> + 0x00, 0x67, 0x7b, 0xe9, 0x0f, 0x55, 0x49, 0xbb,
> + 0x92, 0x18, 0x98, 0xf5, 0x5e, 0xbc, 0xe7, 0x5a,
> + 0x9d, 0x3d, 0xc7, 0xbd, 0x59, 0xec, 0x82, 0x8e
> +};
> +enum { nonce41 = 0x5da05e4c8dfab464ULL };
> +
> +static const u8 input42[] __initconst = {
> + 0xca, 0x30, 0xcd, 0x63, 0xf0, 0x2d, 0xf1, 0x03,
> + 0x4d, 0x0d, 0xf2, 0xf7, 0x6f, 0xae, 0xd6, 0x34,
> + 0xea, 0xf6, 0x13, 0xcf, 0x1c, 0xa0, 0xd0, 0xe8,
> + 0xa4, 0x78, 0x80, 0x3b, 0x1e, 0xa5, 0x32, 0x4c,
> + 0x73, 0x12, 0xd4, 0x6a, 0x94, 0xbc, 0xba, 0x80,
> + 0x5e
> +};
> +static const u8 output42[] __initconst = {
> + 0xec, 0x3f, 0x18, 0x31, 0xc0, 0x7b, 0xb5, 0xe2,
> + 0xad, 0xf3, 0xec, 0xa0, 0x16, 0x9d, 0xef, 0xce,
> + 0x05, 0x65, 0x59, 0x9d, 0x5a, 0xca, 0x3e, 0x13,
> + 0xb9, 0x5d, 0x5d, 0xb5, 0xeb, 0xae, 0xc0, 0x87,
> + 0xbb, 0xfd, 0xe7, 0xe4, 0x89, 0x5b, 0xd2, 0x6c,
> + 0x56
> +};
> +static const u8 key42[] __initconst = {
> + 0x7c, 0x6b, 0x7e, 0x77, 0xcc, 0x8c, 0x1b, 0x03,
> + 0x8b, 0x2a, 0xb3, 0x7c, 0x5a, 0x73, 0xcc, 0xac,
> + 0xdd, 0x53, 0x54, 0x0c, 0x85, 0xed, 0xcd, 0x47,
> + 0x24, 0xc1, 0xb8, 0x9b, 0x2e, 0x41, 0x92, 0x36
> +};
> +enum { nonce42 = 0xe4d7348b09682c9cULL };
> +
> +static const u8 input43[] __initconst = {
> + 0x52, 0xf2, 0x4b, 0x7c, 0xe5, 0x58, 0xe8, 0xd2,
> + 0xb7, 0xf3, 0xa1, 0x29, 0x68, 0xa2, 0x50, 0x50,
> + 0xae, 0x9c, 0x1b, 0xe2, 0x67, 0x77, 0xe2, 0xdb,
> + 0x85, 0x55, 0x7e, 0x84, 0x8a, 0x12, 0x3c, 0xb6,
> + 0x2e, 0xed, 0xd3, 0xec, 0x47, 0x68, 0xfa, 0x52,
> + 0x46, 0x9d
> +};
> +static const u8 output43[] __initconst = {
> + 0x1b, 0xf0, 0x05, 0xe4, 0x1c, 0xd8, 0x74, 0x9a,
> + 0xf0, 0xee, 0x00, 0x54, 0xce, 0x02, 0x83, 0x15,
> + 0xfb, 0x23, 0x35, 0x78, 0xc3, 0xda, 0x98, 0xd8,
> + 0x9d, 0x1b, 0xb2, 0x51, 0x82, 0xb0, 0xff, 0xbe,
> + 0x05, 0xa9, 0xa4, 0x04, 0xba, 0xea, 0x4b, 0x73,
> + 0x47, 0x6e
> +};
> +static const u8 key43[] __initconst = {
> + 0xeb, 0xec, 0x0e, 0xa1, 0x65, 0xe2, 0x99, 0x46,
> + 0xd8, 0x54, 0x8c, 0x4a, 0x93, 0xdf, 0x6d, 0xbf,
> + 0x93, 0x34, 0x94, 0x57, 0xc9, 0x12, 0x9d, 0x68,
> + 0x05, 0xc5, 0x05, 0xad, 0x5a, 0xc9, 0x2a, 0x3b
> +};
> +enum { nonce43 = 0xe14f6a902b7827fULL };
> +
> +static const u8 input44[] __initconst = {
> + 0x3e, 0x22, 0x3e, 0x8e, 0xcd, 0x18, 0xe2, 0xa3,
> + 0x8d, 0x8b, 0x38, 0xc3, 0x02, 0xa3, 0x31, 0x48,
> + 0xc6, 0x0e, 0xec, 0x99, 0x51, 0x11, 0x6d, 0x8b,
> + 0x32, 0x35, 0x3b, 0x08, 0x58, 0x76, 0x25, 0x30,
> + 0xe2, 0xfc, 0xa2, 0x46, 0x7d, 0x6e, 0x34, 0x87,
> + 0xac, 0x42, 0xbf
> +};
> +static const u8 output44[] __initconst = {
> + 0x08, 0x92, 0x58, 0x02, 0x1a, 0xf4, 0x1f, 0x3d,
> + 0x38, 0x7b, 0x6b, 0xf6, 0x84, 0x07, 0xa3, 0x19,
> + 0x17, 0x2a, 0xed, 0x57, 0x1c, 0xf9, 0x55, 0x37,
> + 0x4e, 0xf4, 0x68, 0x68, 0x82, 0x02, 0x4f, 0xca,
> + 0x21, 0x00, 0xc6, 0x66, 0x79, 0x53, 0x19, 0xef,
> + 0x7f, 0xdd, 0x74
> +};
> +static const u8 key44[] __initconst = {
> + 0x73, 0xb6, 0x3e, 0xf4, 0x57, 0x52, 0xa6, 0x43,
> + 0x51, 0xd8, 0x25, 0x00, 0xdb, 0xb4, 0x52, 0x69,
> + 0xd6, 0x27, 0x49, 0xeb, 0x9b, 0xf1, 0x7b, 0xa0,
> + 0xd6, 0x7c, 0x9c, 0xd8, 0x95, 0x03, 0x69, 0x26
> +};
> +enum { nonce44 = 0xf5e6dc4f35ce24e5ULL };
> +
> +static const u8 input45[] __initconst = {
> + 0x55, 0x76, 0xc0, 0xf1, 0x74, 0x03, 0x7a, 0x6d,
> + 0x14, 0xd8, 0x36, 0x2c, 0x9f, 0x9a, 0x59, 0x7a,
> + 0x2a, 0xf5, 0x77, 0x84, 0x70, 0x7c, 0x1d, 0x04,
> + 0x90, 0x45, 0xa4, 0xc1, 0x5e, 0xdd, 0x2e, 0x07,
> + 0x18, 0x34, 0xa6, 0x85, 0x56, 0x4f, 0x09, 0xaf,
> + 0x2f, 0x83, 0xe1, 0xc6
> +};
> +static const u8 output45[] __initconst = {
> + 0x22, 0x46, 0xe4, 0x0b, 0x3a, 0x55, 0xcc, 0x9b,
> + 0xf0, 0xc0, 0x53, 0xcd, 0x95, 0xc7, 0x57, 0x6c,
> + 0x77, 0x46, 0x41, 0x72, 0x07, 0xbf, 0xa8, 0xe5,
> + 0x68, 0x69, 0xd8, 0x1e, 0x45, 0xc1, 0xa2, 0x50,
> + 0xa5, 0xd1, 0x62, 0xc9, 0x5a, 0x7d, 0x08, 0x14,
> + 0xae, 0x44, 0x16, 0xb9
> +};
> +static const u8 key45[] __initconst = {
> + 0x41, 0xf3, 0x88, 0xb2, 0x51, 0x25, 0x47, 0x02,
> + 0x39, 0xe8, 0x15, 0x3a, 0x22, 0x78, 0x86, 0x0b,
> + 0xf9, 0x1e, 0x8d, 0x98, 0xb2, 0x22, 0x82, 0xac,
> + 0x42, 0x94, 0xde, 0x64, 0xf0, 0xfd, 0xb3, 0x6c
> +};
> +enum { nonce45 = 0xf51a582daf4aa01aULL };
> +
> +static const u8 input46[] __initconst = {
> + 0xf6, 0xff, 0x20, 0xf9, 0x26, 0x7e, 0x0f, 0xa8,
> + 0x6a, 0x45, 0x5a, 0x91, 0x73, 0xc4, 0x4c, 0x63,
> + 0xe5, 0x61, 0x59, 0xca, 0xec, 0xc0, 0x20, 0x35,
> + 0xbc, 0x9f, 0x58, 0x9c, 0x5e, 0xa1, 0x17, 0x46,
> + 0xcc, 0xab, 0x6e, 0xd0, 0x4f, 0x24, 0xeb, 0x05,
> + 0x4d, 0x40, 0x41, 0xe0, 0x9d
> +};
> +static const u8 output46[] __initconst = {
> + 0x31, 0x6e, 0x63, 0x3f, 0x9c, 0xe6, 0xb1, 0xb7,
> + 0xef, 0x47, 0x46, 0xd7, 0xb1, 0x53, 0x42, 0x2f,
> + 0x2c, 0xc8, 0x01, 0xae, 0x8b, 0xec, 0x42, 0x2c,
> + 0x6b, 0x2c, 0x9c, 0xb2, 0xf0, 0x29, 0x06, 0xa5,
> + 0xcd, 0x7e, 0xc7, 0x3a, 0x38, 0x98, 0x8a, 0xde,
> + 0x03, 0x29, 0x14, 0x8f, 0xf9
> +};
> +static const u8 key46[] __initconst = {
> + 0xac, 0xa6, 0x44, 0x4a, 0x0d, 0x42, 0x10, 0xbc,
> + 0xd3, 0xc9, 0x8e, 0x9e, 0x71, 0xa3, 0x1c, 0x14,
> + 0x9d, 0x65, 0x0d, 0x49, 0x4d, 0x8c, 0xec, 0x46,
> + 0xe1, 0x41, 0xcd, 0xf5, 0xfc, 0x82, 0x75, 0x34
> +};
> +enum { nonce46 = 0x25f85182df84dec5ULL };
> +
> +static const u8 input47[] __initconst = {
> + 0xa1, 0xd2, 0xf2, 0x52, 0x2f, 0x79, 0x50, 0xb2,
> + 0x42, 0x29, 0x5b, 0x44, 0x20, 0xf9, 0xbd, 0x85,
> + 0xb7, 0x65, 0x77, 0x86, 0xce, 0x3e, 0x1c, 0xe4,
> + 0x70, 0x80, 0xdd, 0x72, 0x07, 0x48, 0x0f, 0x84,
> + 0x0d, 0xfd, 0x97, 0xc0, 0xb7, 0x48, 0x9b, 0xb4,
> + 0xec, 0xff, 0x73, 0x14, 0x99, 0xe4
> +};
> +static const u8 output47[] __initconst = {
> + 0xe5, 0x3c, 0x78, 0x66, 0x31, 0x1e, 0xd6, 0xc4,
> + 0x9e, 0x71, 0xb3, 0xd7, 0xd5, 0xad, 0x84, 0xf2,
> + 0x78, 0x61, 0x77, 0xf8, 0x31, 0xf0, 0x13, 0xad,
> + 0x66, 0xf5, 0x31, 0x7d, 0xeb, 0xdf, 0xaf, 0xcb,
> + 0xac, 0x28, 0x6c, 0xc2, 0x9e, 0xe7, 0x78, 0xa2,
> + 0xa2, 0x58, 0xce, 0x84, 0x76, 0x70
> +};
> +static const u8 key47[] __initconst = {
> + 0x05, 0x7f, 0xc0, 0x7f, 0x37, 0x20, 0x71, 0x02,
> + 0x3a, 0xe7, 0x20, 0x5a, 0x0a, 0x8f, 0x79, 0x5a,
> + 0xfe, 0xbb, 0x43, 0x4d, 0x2f, 0xcb, 0xf6, 0x9e,
> + 0xa2, 0x97, 0x00, 0xad, 0x0d, 0x51, 0x7e, 0x17
> +};
> +enum { nonce47 = 0xae707c60f54de32bULL };
> +
> +static const u8 input48[] __initconst = {
> + 0x80, 0x93, 0x77, 0x2e, 0x8d, 0xe8, 0xe6, 0xc1,
> + 0x27, 0xe6, 0xf2, 0x89, 0x5b, 0x33, 0x62, 0x18,
> + 0x80, 0x6e, 0x17, 0x22, 0x8e, 0x83, 0x31, 0x40,
> + 0x8f, 0xc9, 0x5c, 0x52, 0x6c, 0x0e, 0xa5, 0xe9,
> + 0x6c, 0x7f, 0xd4, 0x6a, 0x27, 0x56, 0x99, 0xce,
> + 0x8d, 0x37, 0x59, 0xaf, 0xc0, 0x0e, 0xe1
> +};
> +static const u8 output48[] __initconst = {
> + 0x02, 0xa4, 0x2e, 0x33, 0xb7, 0x7c, 0x2b, 0x9a,
> + 0x18, 0x5a, 0xba, 0x53, 0x38, 0xaf, 0x00, 0xeb,
> + 0xd8, 0x3d, 0x02, 0x77, 0x43, 0x45, 0x03, 0x91,
> + 0xe2, 0x5e, 0x4e, 0xeb, 0x50, 0xd5, 0x5b, 0xe0,
> + 0xf3, 0x33, 0xa7, 0xa2, 0xac, 0x07, 0x6f, 0xeb,
> + 0x3f, 0x6c, 0xcd, 0xf2, 0x6c, 0x61, 0x64
> +};
> +static const u8 key48[] __initconst = {
> + 0xf3, 0x79, 0xe7, 0xf8, 0x0e, 0x02, 0x05, 0x6b,
> + 0x83, 0x1a, 0xe7, 0x86, 0x6b, 0xe6, 0x8f, 0x3f,
> + 0xd3, 0xa3, 0xe4, 0x6e, 0x29, 0x06, 0xad, 0xbc,
> + 0xe8, 0x33, 0x56, 0x39, 0xdf, 0xb0, 0xe2, 0xfe
> +};
> +enum { nonce48 = 0xd849b938c6569da0ULL };
> +
> +static const u8 input49[] __initconst = {
> + 0x89, 0x3b, 0x88, 0x9e, 0x7b, 0x38, 0x16, 0x9f,
> + 0xa1, 0x28, 0xf6, 0xf5, 0x23, 0x74, 0x28, 0xb0,
> + 0xdf, 0x6c, 0x9e, 0x8a, 0x71, 0xaf, 0xed, 0x7a,
> + 0x39, 0x21, 0x57, 0x7d, 0x31, 0x6c, 0xee, 0x0d,
> + 0x11, 0x8d, 0x41, 0x9a, 0x5f, 0xb7, 0x27, 0x40,
> + 0x08, 0xad, 0xc6, 0xe0, 0x00, 0x43, 0x9e, 0xae
> +};
> +static const u8 output49[] __initconst = {
> + 0x4d, 0xfd, 0xdb, 0x4c, 0x77, 0xc1, 0x05, 0x07,
> + 0x4d, 0x6d, 0x32, 0xcb, 0x2e, 0x0e, 0xff, 0x65,
> + 0xc9, 0x27, 0xeb, 0xa9, 0x46, 0x5b, 0xab, 0x06,
> + 0xe6, 0xb6, 0x5a, 0x1e, 0x00, 0xfb, 0xcf, 0xe4,
> + 0xb9, 0x71, 0x40, 0x10, 0xef, 0x12, 0x39, 0xf0,
> + 0xea, 0x40, 0xb8, 0x9a, 0xa2, 0x85, 0x38, 0x48
> +};
> +static const u8 key49[] __initconst = {
> + 0xe7, 0x10, 0x40, 0xd9, 0x66, 0xc0, 0xa8, 0x6d,
> + 0xa3, 0xcc, 0x8b, 0xdd, 0x93, 0xf2, 0x6e, 0xe0,
> + 0x90, 0x7f, 0xd0, 0xf4, 0x37, 0x0c, 0x8b, 0x9b,
> + 0x4c, 0x4d, 0xe6, 0xf2, 0x1f, 0xe9, 0x95, 0x24
> +};
> +enum { nonce49 = 0xf269817bdae01bc0ULL };
> +
> +static const u8 input50[] __initconst = {
> + 0xda, 0x5b, 0x60, 0xcd, 0xed, 0x58, 0x8e, 0x7f,
> + 0xae, 0xdd, 0xc8, 0x2e, 0x16, 0x90, 0xea, 0x4b,
> + 0x0c, 0x74, 0x14, 0x35, 0xeb, 0xee, 0x2c, 0xff,
> + 0x46, 0x99, 0x97, 0x6e, 0xae, 0xa7, 0x8e, 0x6e,
> + 0x38, 0xfe, 0x63, 0xe7, 0x51, 0xd9, 0xaa, 0xce,
> + 0x7b, 0x1e, 0x7e, 0x5d, 0xc0, 0xe8, 0x10, 0x06,
> + 0x14
> +};
> +static const u8 output50[] __initconst = {
> + 0xe4, 0xe5, 0x86, 0x1b, 0x66, 0x19, 0xac, 0x49,
> + 0x1c, 0xbd, 0xee, 0x03, 0xaf, 0x11, 0xfc, 0x1f,
> + 0x6a, 0xd2, 0x50, 0x5c, 0xea, 0x2c, 0xa5, 0x75,
> + 0xfd, 0xb7, 0x0e, 0x80, 0x8f, 0xed, 0x3f, 0x31,
> + 0x47, 0xac, 0x67, 0x43, 0xb8, 0x2e, 0xb4, 0x81,
> + 0x6d, 0xe4, 0x1e, 0xb7, 0x8b, 0x0c, 0x53, 0xa9,
> + 0x26
> +};
> +static const u8 key50[] __initconst = {
> + 0xd7, 0xb2, 0x04, 0x76, 0x30, 0xcc, 0x38, 0x45,
> + 0xef, 0xdb, 0xc5, 0x86, 0x08, 0x61, 0xf0, 0xee,
> + 0x6d, 0xd8, 0x22, 0x04, 0x8c, 0xfb, 0xcb, 0x37,
> + 0xa6, 0xfb, 0x95, 0x22, 0xe1, 0x87, 0xb7, 0x6f
> +};
> +enum { nonce50 = 0x3b44d09c45607d38ULL };
> +
> +static const u8 input51[] __initconst = {
> + 0xa9, 0x41, 0x02, 0x4b, 0xd7, 0xd5, 0xd1, 0xf1,
> + 0x21, 0x55, 0xb2, 0x75, 0x6d, 0x77, 0x1b, 0x86,
> + 0xa9, 0xc8, 0x90, 0xfd, 0xed, 0x4a, 0x7b, 0x6c,
> + 0xb2, 0x5f, 0x9b, 0x5f, 0x16, 0xa1, 0x54, 0xdb,
> + 0xd6, 0x3f, 0x6a, 0x7f, 0x2e, 0x51, 0x9d, 0x49,
> + 0x5b, 0xa5, 0x0e, 0xf9, 0xfb, 0x2a, 0x38, 0xff,
> + 0x20, 0x8c
> +};
> +static const u8 output51[] __initconst = {
> + 0x18, 0xf7, 0x88, 0xc1, 0x72, 0xfd, 0x90, 0x4b,
> + 0xa9, 0x2d, 0xdb, 0x47, 0xb0, 0xa5, 0xc4, 0x37,
> + 0x01, 0x95, 0xc4, 0xb1, 0xab, 0xc5, 0x5b, 0xcd,
> + 0xe1, 0x97, 0x78, 0x13, 0xde, 0x6a, 0xff, 0x36,
> + 0xce, 0xa4, 0x67, 0xc5, 0x4a, 0x45, 0x2b, 0xd9,
> + 0xff, 0x8f, 0x06, 0x7c, 0x63, 0xbb, 0x83, 0x17,
> + 0xb4, 0x6b
> +};
> +static const u8 key51[] __initconst = {
> + 0x82, 0x1a, 0x79, 0xab, 0x9a, 0xb5, 0x49, 0x6a,
> + 0x30, 0x6b, 0x99, 0x19, 0x11, 0xc7, 0xa2, 0xf4,
> + 0xca, 0x55, 0xb9, 0xdd, 0xe7, 0x2f, 0xe7, 0xc1,
> + 0xdd, 0x27, 0xad, 0x80, 0xf2, 0x56, 0xad, 0xf3
> +};
> +enum { nonce51 = 0xe93aff94ca71a4a6ULL };
> +
> +static const u8 input52[] __initconst = {
> + 0x89, 0xdd, 0xf3, 0xfa, 0xb6, 0xc1, 0xaa, 0x9a,
> + 0xc8, 0xad, 0x6b, 0x00, 0xa1, 0x65, 0xea, 0x14,
> + 0x55, 0x54, 0x31, 0x8f, 0xf0, 0x03, 0x84, 0x51,
> + 0x17, 0x1e, 0x0a, 0x93, 0x6e, 0x79, 0x96, 0xa3,
> + 0x2a, 0x85, 0x9c, 0x89, 0xf8, 0xd1, 0xe2, 0x15,
> + 0x95, 0x05, 0xf4, 0x43, 0x4d, 0x6b, 0xf0, 0x71,
> + 0x3b, 0x3e, 0xba
> +};
> +static const u8 output52[] __initconst = {
> + 0x0c, 0x42, 0x6a, 0xb3, 0x66, 0x63, 0x5d, 0x2c,
> + 0x9f, 0x3d, 0xa6, 0x6e, 0xc7, 0x5f, 0x79, 0x2f,
> + 0x50, 0xe3, 0xd6, 0x07, 0x56, 0xa4, 0x2b, 0x2d,
> + 0x8d, 0x10, 0xc0, 0x6c, 0xa2, 0xfc, 0x97, 0xec,
> + 0x3f, 0x5c, 0x8d, 0x59, 0xbe, 0x84, 0xf1, 0x3e,
> + 0x38, 0x47, 0x4f, 0x75, 0x25, 0x66, 0x88, 0x14,
> + 0x03, 0xdd, 0xde
> +};
> +static const u8 key52[] __initconst = {
> + 0x4f, 0xb0, 0x27, 0xb6, 0xdd, 0x24, 0x0c, 0xdb,
> + 0x6b, 0x71, 0x2e, 0xac, 0xfc, 0x3f, 0xa6, 0x48,
> + 0x5d, 0xd5, 0xff, 0x53, 0xb5, 0x62, 0xf1, 0xe0,
> + 0x93, 0xfe, 0x39, 0x4c, 0x9f, 0x03, 0x11, 0xa7
> +};
> +enum { nonce52 = 0xed8becec3bdf6f25ULL };
> +
> +static const u8 input53[] __initconst = {
> + 0x68, 0xd1, 0xc7, 0x74, 0x44, 0x1c, 0x84, 0xde,
> + 0x27, 0x27, 0x35, 0xf0, 0x18, 0x0b, 0x57, 0xaa,
> + 0xd0, 0x1a, 0xd3, 0x3b, 0x5e, 0x5c, 0x62, 0x93,
> + 0xd7, 0x6b, 0x84, 0x3b, 0x71, 0x83, 0x77, 0x01,
> + 0x3e, 0x59, 0x45, 0xf4, 0x77, 0x6c, 0x6b, 0xcb,
> + 0x88, 0x45, 0x09, 0x1d, 0xc6, 0x45, 0x6e, 0xdc,
> + 0x6e, 0x51, 0xb8, 0x28
> +};
> +static const u8 output53[] __initconst = {
> + 0xc5, 0x90, 0x96, 0x78, 0x02, 0xf5, 0xc4, 0x3c,
> + 0xde, 0xd4, 0xd4, 0xc6, 0xa7, 0xad, 0x12, 0x47,
> + 0x45, 0xce, 0xcd, 0x8c, 0x35, 0xcc, 0xa6, 0x9e,
> + 0x5a, 0xc6, 0x60, 0xbb, 0xe3, 0xed, 0xec, 0x68,
> + 0x3f, 0x64, 0xf7, 0x06, 0x63, 0x9c, 0x8c, 0xc8,
> + 0x05, 0x3a, 0xad, 0x32, 0x79, 0x8b, 0x45, 0x96,
> + 0x93, 0x73, 0x4c, 0xe0
> +};
> +static const u8 key53[] __initconst = {
> + 0x42, 0x4b, 0x20, 0x81, 0x49, 0x50, 0xe9, 0xc2,
> + 0x43, 0x69, 0x36, 0xe7, 0x68, 0xae, 0xd5, 0x7e,
> + 0x42, 0x1a, 0x1b, 0xb4, 0x06, 0x4d, 0xa7, 0x17,
> + 0xb5, 0x31, 0xd6, 0x0c, 0xb0, 0x5c, 0x41, 0x0b
> +};
> +enum { nonce53 = 0xf44ce1931fbda3d7ULL };
> +
> +static const u8 input54[] __initconst = {
> + 0x7b, 0xf6, 0x8b, 0xae, 0xc0, 0xcb, 0x10, 0x8e,
> + 0xe8, 0xd8, 0x2e, 0x3b, 0x14, 0xba, 0xb4, 0xd2,
> + 0x58, 0x6b, 0x2c, 0xec, 0xc1, 0x81, 0x71, 0xb4,
> + 0xc6, 0xea, 0x08, 0xc5, 0xc9, 0x78, 0xdb, 0xa2,
> + 0xfa, 0x44, 0x50, 0x9b, 0xc8, 0x53, 0x8d, 0x45,
> + 0x42, 0xe7, 0x09, 0xc4, 0x29, 0xd8, 0x75, 0x02,
> + 0xbb, 0xb2, 0x78, 0xcf, 0xe7
> +};
> +static const u8 output54[] __initconst = {
> + 0xaf, 0x2c, 0x83, 0x26, 0x6e, 0x7f, 0xa6, 0xe9,
> + 0x03, 0x75, 0xfe, 0xfe, 0x87, 0x58, 0xcf, 0xb5,
> + 0xbc, 0x3c, 0x9d, 0xa1, 0x6e, 0x13, 0xf1, 0x0f,
> + 0x9e, 0xbc, 0xe0, 0x54, 0x24, 0x32, 0xce, 0x95,
> + 0xe6, 0xa5, 0x59, 0x3d, 0x24, 0x1d, 0x8f, 0xb1,
> + 0x74, 0x6c, 0x56, 0xe7, 0x96, 0xc1, 0x91, 0xc8,
> + 0x2d, 0x0e, 0xb7, 0x51, 0x10
> +};
> +static const u8 key54[] __initconst = {
> + 0x00, 0x68, 0x74, 0xdc, 0x30, 0x9e, 0xe3, 0x52,
> + 0xa9, 0xae, 0xb6, 0x7c, 0xa1, 0xdc, 0x12, 0x2d,
> + 0x98, 0x32, 0x7a, 0x77, 0xe1, 0xdd, 0xa3, 0x76,
> + 0x72, 0x34, 0x83, 0xd8, 0xb7, 0x69, 0xba, 0x77
> +};
> +enum { nonce54 = 0xbea57d79b798b63aULL };
> +
> +static const u8 input55[] __initconst = {
> + 0xb5, 0xf4, 0x2f, 0xc1, 0x5e, 0x10, 0xa7, 0x4e,
> + 0x74, 0x3d, 0xa3, 0x96, 0xc0, 0x4d, 0x7b, 0x92,
> + 0x8f, 0xdb, 0x2d, 0x15, 0x52, 0x6a, 0x95, 0x5e,
> + 0x40, 0x81, 0x4f, 0x70, 0x73, 0xea, 0x84, 0x65,
> + 0x3d, 0x9a, 0x4e, 0x03, 0x95, 0xf8, 0x5d, 0x2f,
> + 0x07, 0x02, 0x13, 0x13, 0xdd, 0x82, 0xe6, 0x3b,
> + 0xe1, 0x5f, 0xb3, 0x37, 0x9b, 0x88
> +};
> +static const u8 output55[] __initconst = {
> + 0xc1, 0x88, 0xbd, 0x92, 0x77, 0xad, 0x7c, 0x5f,
> + 0xaf, 0xa8, 0x57, 0x0e, 0x40, 0x0a, 0xdc, 0x70,
> + 0xfb, 0xc6, 0x71, 0xfd, 0xc4, 0x74, 0x60, 0xcc,
> + 0xa0, 0x89, 0x8e, 0x99, 0xf0, 0x06, 0xa6, 0x7c,
> + 0x97, 0x42, 0x21, 0x81, 0x6a, 0x07, 0xe7, 0xb3,
> + 0xf7, 0xa5, 0x03, 0x71, 0x50, 0x05, 0x63, 0x17,
> + 0xa9, 0x46, 0x0b, 0xff, 0x30, 0x78
> +};
> +static const u8 key55[] __initconst = {
> + 0x19, 0x8f, 0xe7, 0xd7, 0x6b, 0x7f, 0x6f, 0x69,
> + 0x86, 0x91, 0x0f, 0xa7, 0x4a, 0x69, 0x8e, 0x34,
> + 0xf3, 0xdb, 0xde, 0xaf, 0xf2, 0x66, 0x1d, 0x64,
> + 0x97, 0x0c, 0xcf, 0xfa, 0x33, 0x84, 0xfd, 0x0c
> +};
> +enum { nonce55 = 0x80aa3d3e2c51ef06ULL };
> +
> +static const u8 input56[] __initconst = {
> + 0x6b, 0xe9, 0x73, 0x42, 0x27, 0x5e, 0x12, 0xcd,
> + 0xaa, 0x45, 0x12, 0x8b, 0xb3, 0xe6, 0x54, 0x33,
> + 0x31, 0x7d, 0xe2, 0x25, 0xc6, 0x86, 0x47, 0x67,
> + 0x86, 0x83, 0xe4, 0x46, 0xb5, 0x8f, 0x2c, 0xbb,
> + 0xe4, 0xb8, 0x9f, 0xa2, 0xa4, 0xe8, 0x75, 0x96,
> + 0x92, 0x51, 0x51, 0xac, 0x8e, 0x2e, 0x6f, 0xfc,
> + 0xbd, 0x0d, 0xa3, 0x9f, 0x16, 0x55, 0x3e
> +};
> +static const u8 output56[] __initconst = {
> + 0x42, 0x99, 0x73, 0x6c, 0xd9, 0x4b, 0x16, 0xe5,
> + 0x18, 0x63, 0x1a, 0xd9, 0x0e, 0xf1, 0x15, 0x2e,
> + 0x0f, 0x4b, 0xe4, 0x5f, 0xa0, 0x4d, 0xde, 0x9f,
> + 0xa7, 0x18, 0xc1, 0x0c, 0x0b, 0xae, 0x55, 0xe4,
> + 0x89, 0x18, 0xa4, 0x78, 0x9d, 0x25, 0x0d, 0xd5,
> + 0x94, 0x0f, 0xf9, 0x78, 0xa3, 0xa6, 0xe9, 0x9e,
> + 0x2c, 0x73, 0xf0, 0xf7, 0x35, 0xf3, 0x2b
> +};
> +static const u8 key56[] __initconst = {
> + 0x7d, 0x12, 0xad, 0x51, 0xd5, 0x6f, 0x8f, 0x96,
> + 0xc0, 0x5d, 0x9a, 0xd1, 0x7e, 0x20, 0x98, 0x0e,
> + 0x3c, 0x0a, 0x67, 0x6b, 0x1b, 0x88, 0x69, 0xd4,
> + 0x07, 0x8c, 0xaf, 0x0f, 0x3a, 0x28, 0xe4, 0x5d
> +};
> +enum { nonce56 = 0x70f4c372fb8b5984ULL };
> +
> +static const u8 input57[] __initconst = {
> + 0x28, 0xa3, 0x06, 0xe8, 0xe7, 0x08, 0xb9, 0xef,
> + 0x0d, 0x63, 0x15, 0x99, 0xb2, 0x78, 0x7e, 0xaf,
> + 0x30, 0x50, 0xcf, 0xea, 0xc9, 0x91, 0x41, 0x2f,
> + 0x3b, 0x38, 0x70, 0xc4, 0x87, 0xb0, 0x3a, 0xee,
> + 0x4a, 0xea, 0xe3, 0x83, 0x68, 0x8b, 0xcf, 0xda,
> + 0x04, 0xa5, 0xbd, 0xb2, 0xde, 0x3c, 0x55, 0x13,
> + 0xfe, 0x96, 0xad, 0xc1, 0x61, 0x1b, 0x98, 0xde
> +};
> +static const u8 output57[] __initconst = {
> + 0xf4, 0x44, 0xe9, 0xd2, 0x6d, 0xc2, 0x5a, 0xe9,
> + 0xfd, 0x7e, 0x41, 0x54, 0x3f, 0xf4, 0x12, 0xd8,
> + 0x55, 0x0d, 0x12, 0x9b, 0xd5, 0x2e, 0x95, 0xe5,
> + 0x77, 0x42, 0x3f, 0x2c, 0xfb, 0x28, 0x9d, 0x72,
> + 0x6d, 0x89, 0x82, 0x27, 0x64, 0x6f, 0x0d, 0x57,
> + 0xa1, 0x25, 0xa3, 0x6b, 0x88, 0x9a, 0xac, 0x0c,
> + 0x76, 0x19, 0x90, 0xe2, 0x50, 0x5a, 0xf8, 0x12
> +};
> +static const u8 key57[] __initconst = {
> + 0x08, 0x26, 0xb8, 0xac, 0xf3, 0xa5, 0xc6, 0xa3,
> + 0x7f, 0x09, 0x87, 0xf5, 0x6c, 0x5a, 0x85, 0x6c,
> + 0x3d, 0xbd, 0xde, 0xd5, 0x87, 0xa3, 0x98, 0x7a,
> + 0xaa, 0x40, 0x3e, 0xf7, 0xff, 0x44, 0x5d, 0xee
> +};
> +enum { nonce57 = 0xc03a6130bf06b089ULL };
> +
> +static const u8 input58[] __initconst = {
> + 0x82, 0xa5, 0x38, 0x6f, 0xaa, 0xb4, 0xaf, 0xb2,
> + 0x42, 0x01, 0xa8, 0x39, 0x3f, 0x15, 0x51, 0xa8,
> + 0x11, 0x1b, 0x93, 0xca, 0x9c, 0xa0, 0x57, 0x68,
> + 0x8f, 0xdb, 0x68, 0x53, 0x51, 0x6d, 0x13, 0x22,
> + 0x12, 0x9b, 0xbd, 0x33, 0xa8, 0x52, 0x40, 0x57,
> + 0x80, 0x9b, 0x98, 0xef, 0x56, 0x70, 0x11, 0xfa,
> + 0x36, 0x69, 0x7d, 0x15, 0x48, 0xf9, 0x3b, 0xeb,
> + 0x42
> +};
> +static const u8 output58[] __initconst = {
> + 0xff, 0x3a, 0x74, 0xc3, 0x3e, 0x44, 0x64, 0x4d,
> + 0x0e, 0x5f, 0x9d, 0xa8, 0xdb, 0xbe, 0x12, 0xef,
> + 0xba, 0x56, 0x65, 0x50, 0x76, 0xaf, 0xa4, 0x4e,
> + 0x01, 0xc1, 0xd3, 0x31, 0x14, 0xe2, 0xbe, 0x7b,
> + 0xa5, 0x67, 0xb4, 0xe3, 0x68, 0x40, 0x9c, 0xb0,
> + 0xb1, 0x78, 0xef, 0x49, 0x03, 0x0f, 0x2d, 0x56,
> + 0xb4, 0x37, 0xdb, 0xbc, 0x2d, 0x68, 0x1c, 0x3c,
> + 0xf1
> +};
> +static const u8 key58[] __initconst = {
> + 0x7e, 0xf1, 0x7c, 0x20, 0x65, 0xed, 0xcd, 0xd7,
> + 0x57, 0xe8, 0xdb, 0x90, 0x87, 0xdb, 0x5f, 0x63,
> + 0x3d, 0xdd, 0xb8, 0x2b, 0x75, 0x8e, 0x04, 0xb5,
> + 0xf4, 0x12, 0x79, 0xa9, 0x4d, 0x42, 0x16, 0x7f
> +};
> +enum { nonce58 = 0x92838183f80d2f7fULL };
> +
> +static const u8 input59[] __initconst = {
> + 0x37, 0xf1, 0x9d, 0xdd, 0xd7, 0x08, 0x9f, 0x13,
> + 0xc5, 0x21, 0x82, 0x75, 0x08, 0x9e, 0x25, 0x16,
> + 0xb1, 0xd1, 0x71, 0x42, 0x28, 0x63, 0xac, 0x47,
> + 0x71, 0x54, 0xb1, 0xfc, 0x39, 0xf0, 0x61, 0x4f,
> + 0x7c, 0x6d, 0x4f, 0xc8, 0x33, 0xef, 0x7e, 0xc8,
> + 0xc0, 0x97, 0xfc, 0x1a, 0x61, 0xb4, 0x87, 0x6f,
> + 0xdd, 0x5a, 0x15, 0x7b, 0x1b, 0x95, 0x50, 0x94,
> + 0x1d, 0xba
> +};
> +static const u8 output59[] __initconst = {
> + 0x73, 0x67, 0xc5, 0x07, 0xbb, 0x57, 0x79, 0xd5,
> + 0xc9, 0x04, 0xdd, 0x88, 0xf3, 0x86, 0xe5, 0x70,
> + 0x49, 0x31, 0xe0, 0xcc, 0x3b, 0x1d, 0xdf, 0xb0,
> + 0xaf, 0xf4, 0x2d, 0xe0, 0x06, 0x10, 0x91, 0x8d,
> + 0x1c, 0xcf, 0x31, 0x0b, 0xf6, 0x73, 0xda, 0x1c,
> + 0xf0, 0x17, 0x52, 0x9e, 0x20, 0x2e, 0x9f, 0x8c,
> + 0xb3, 0x59, 0xce, 0xd4, 0xd3, 0xc1, 0x81, 0xe9,
> + 0x11, 0x36
> +};
> +static const u8 key59[] __initconst = {
> + 0xbd, 0x07, 0xd0, 0x53, 0x2c, 0xb3, 0xcc, 0x3f,
> + 0xc4, 0x95, 0xfd, 0xe7, 0x81, 0xb3, 0x29, 0x99,
> + 0x05, 0x45, 0xd6, 0x95, 0x25, 0x0b, 0x72, 0xd3,
> + 0xcd, 0xbb, 0x73, 0xf8, 0xfa, 0xc0, 0x9b, 0x7a
> +};
> +enum { nonce59 = 0x4a0db819b0d519e2ULL };
> +
> +static const u8 input60[] __initconst = {
> + 0x58, 0x4e, 0xdf, 0x94, 0x3c, 0x76, 0x0a, 0x79,
> + 0x47, 0xf1, 0xbe, 0x88, 0xd3, 0xba, 0x94, 0xd8,
> + 0xe2, 0x8f, 0xe3, 0x2f, 0x2f, 0x74, 0x82, 0x55,
> + 0xc3, 0xda, 0xe2, 0x4e, 0x2c, 0x8c, 0x45, 0x1d,
> + 0x72, 0x8f, 0x54, 0x41, 0xb5, 0xb7, 0x69, 0xe4,
> + 0xdc, 0xd2, 0x36, 0x21, 0x5c, 0x28, 0x52, 0xf7,
> + 0x98, 0x8e, 0x72, 0xa7, 0x6d, 0x57, 0xed, 0xdc,
> + 0x3c, 0xe6, 0x6a
> +};
> +static const u8 output60[] __initconst = {
> + 0xda, 0xaf, 0xb5, 0xe3, 0x30, 0x65, 0x5c, 0xb1,
> + 0x48, 0x08, 0x43, 0x7b, 0x9e, 0xd2, 0x6a, 0x62,
> + 0x56, 0x7c, 0xad, 0xd9, 0xe5, 0xf6, 0x09, 0x71,
> + 0xcd, 0xe6, 0x05, 0x6b, 0x3f, 0x44, 0x3a, 0x5c,
> + 0xf6, 0xf8, 0xd7, 0xce, 0x7d, 0xd1, 0xe0, 0x4f,
> + 0x88, 0x15, 0x04, 0xd8, 0x20, 0xf0, 0x3e, 0xef,
> + 0xae, 0xa6, 0x27, 0xa3, 0x0e, 0xfc, 0x18, 0x90,
> + 0x33, 0xcd, 0xd3
> +};
> +static const u8 key60[] __initconst = {
> + 0xbf, 0xfd, 0x25, 0xb5, 0xb2, 0xfc, 0x78, 0x0c,
> + 0x8e, 0xb9, 0x57, 0x2f, 0x26, 0x4a, 0x7e, 0x71,
> + 0xcc, 0xf2, 0xe0, 0xfd, 0x24, 0x11, 0x20, 0x23,
> + 0x57, 0x00, 0xff, 0x80, 0x11, 0x0c, 0x1e, 0xff
> +};
> +enum { nonce60 = 0xf18df56fdb7954adULL };
> +
> +static const u8 input61[] __initconst = {
> + 0xb0, 0xf3, 0x06, 0xbc, 0x22, 0xae, 0x49, 0x40,
> + 0xae, 0xff, 0x1b, 0x31, 0xa7, 0x98, 0xab, 0x1d,
> + 0xe7, 0x40, 0x23, 0x18, 0x4f, 0xab, 0x8e, 0x93,
> + 0x82, 0xf4, 0x56, 0x61, 0xfd, 0x2b, 0xcf, 0xa7,
> + 0xc4, 0xb4, 0x0a, 0xf4, 0xcb, 0xc7, 0x8c, 0x40,
> + 0x57, 0xac, 0x0b, 0x3e, 0x2a, 0x0a, 0x67, 0x83,
> + 0x50, 0xbf, 0xec, 0xb0, 0xc7, 0xf1, 0x32, 0x26,
> + 0x98, 0x80, 0x33, 0xb4
> +};
> +static const u8 output61[] __initconst = {
> + 0x9d, 0x23, 0x0e, 0xff, 0xcc, 0x7c, 0xd5, 0xcf,
> + 0x1a, 0xb8, 0x59, 0x1e, 0x92, 0xfd, 0x7f, 0xca,
> + 0xca, 0x3c, 0x18, 0x81, 0xde, 0xfa, 0x59, 0xc8,
> + 0x6f, 0x9c, 0x24, 0x3f, 0x3a, 0xe6, 0x0b, 0xb4,
> + 0x34, 0x48, 0x69, 0xfc, 0xb6, 0xea, 0xb2, 0xde,
> + 0x9f, 0xfd, 0x92, 0x36, 0x18, 0x98, 0x99, 0xaa,
> + 0x65, 0xe2, 0xea, 0xf4, 0xb1, 0x47, 0x8e, 0xb0,
> + 0xe7, 0xd4, 0x7a, 0x2c
> +};
> +static const u8 key61[] __initconst = {
> + 0xd7, 0xfd, 0x9b, 0xbd, 0x8f, 0x65, 0x0d, 0x00,
> + 0xca, 0xa1, 0x6c, 0x85, 0x85, 0xa4, 0x6d, 0xf1,
> + 0xb1, 0x68, 0x0c, 0x8b, 0x5d, 0x37, 0x72, 0xd0,
> + 0xd8, 0xd2, 0x25, 0xab, 0x9f, 0x7b, 0x7d, 0x95
> +};
> +enum { nonce61 = 0xd82caf72a9c4864fULL };
> +
> +static const u8 input62[] __initconst = {
> + 0x10, 0x77, 0xf3, 0x2f, 0xc2, 0x50, 0xd6, 0x0c,
> + 0xba, 0xa8, 0x8d, 0xce, 0x0d, 0x58, 0x9e, 0x87,
> + 0xb1, 0x59, 0x66, 0x0a, 0x4a, 0xb3, 0xd8, 0xca,
> + 0x0a, 0x6b, 0xf8, 0xc6, 0x2b, 0x3f, 0x8e, 0x09,
> + 0xe0, 0x0a, 0x15, 0x85, 0xfe, 0xaa, 0xc6, 0xbd,
> + 0x30, 0xef, 0xe4, 0x10, 0x78, 0x03, 0xc1, 0xc7,
> + 0x8a, 0xd9, 0xde, 0x0b, 0x51, 0x07, 0xc4, 0x7b,
> + 0xe2, 0x2e, 0x36, 0x3a, 0xc2
> +};
> +static const u8 output62[] __initconst = {
> + 0xa0, 0x0c, 0xfc, 0xc1, 0xf6, 0xaf, 0xc2, 0xb8,
> + 0x5c, 0xef, 0x6e, 0xf3, 0xce, 0x15, 0x48, 0x05,
> + 0xb5, 0x78, 0x49, 0x51, 0x1f, 0x9d, 0xf4, 0xbf,
> + 0x2f, 0x53, 0xa2, 0xd1, 0x15, 0x20, 0x82, 0x6b,
> + 0xd2, 0x22, 0x6c, 0x4e, 0x14, 0x87, 0xe3, 0xd7,
> + 0x49, 0x45, 0x84, 0xdb, 0x5f, 0x68, 0x60, 0xc4,
> + 0xb3, 0xe6, 0x3f, 0xd1, 0xfc, 0xa5, 0x73, 0xf3,
> + 0xfc, 0xbb, 0xbe, 0xc8, 0x9d
> +};
> +static const u8 key62[] __initconst = {
> + 0x6e, 0xc9, 0xaf, 0xce, 0x35, 0xb9, 0x86, 0xd1,
> + 0xce, 0x5f, 0xd9, 0xbb, 0xd5, 0x1f, 0x7c, 0xcd,
> + 0xfe, 0x19, 0xaa, 0x3d, 0xea, 0x64, 0xc1, 0x28,
> + 0x40, 0xba, 0xa1, 0x28, 0xcd, 0x40, 0xb6, 0xf2
> +};
> +enum { nonce62 = 0xa1c0c265f900cde8ULL };
> +
> +static const u8 input63[] __initconst = {
> + 0x7a, 0x70, 0x21, 0x2c, 0xef, 0xa6, 0x36, 0xd4,
> + 0xe0, 0xab, 0x8c, 0x25, 0x73, 0x34, 0xc8, 0x94,
> + 0x6c, 0x81, 0xcb, 0x19, 0x8d, 0x5a, 0x49, 0xaa,
> + 0x6f, 0xba, 0x83, 0x72, 0x02, 0x5e, 0xf5, 0x89,
> + 0xce, 0x79, 0x7e, 0x13, 0x3d, 0x5b, 0x98, 0x60,
> + 0x5d, 0xd9, 0xfb, 0x15, 0x93, 0x4c, 0xf3, 0x51,
> + 0x49, 0x55, 0xd1, 0x58, 0xdd, 0x7e, 0x6d, 0xfe,
> + 0xdd, 0x84, 0x23, 0x05, 0xba, 0xe9
> +};
> +static const u8 output63[] __initconst = {
> + 0x20, 0xb3, 0x5c, 0x03, 0x03, 0x78, 0x17, 0xfc,
> + 0x3b, 0x35, 0x30, 0x9a, 0x00, 0x18, 0xf5, 0xc5,
> + 0x06, 0x53, 0xf5, 0x04, 0x24, 0x9d, 0xd1, 0xb2,
> + 0xac, 0x5a, 0xb6, 0x2a, 0xa5, 0xda, 0x50, 0x00,
> + 0xec, 0xff, 0xa0, 0x7a, 0x14, 0x7b, 0xe4, 0x6b,
> + 0x63, 0xe8, 0x66, 0x86, 0x34, 0xfd, 0x74, 0x44,
> + 0xa2, 0x50, 0x97, 0x0d, 0xdc, 0xc3, 0x84, 0xf8,
> + 0x71, 0x02, 0x31, 0x95, 0xed, 0x54
> +};
> +static const u8 key63[] __initconst = {
> + 0x7d, 0x64, 0xb4, 0x12, 0x81, 0xe4, 0xe6, 0x8f,
> + 0xcc, 0xe7, 0xd1, 0x1f, 0x70, 0x20, 0xfd, 0xb8,
> + 0x3a, 0x7d, 0xa6, 0x53, 0x65, 0x30, 0x5d, 0xe3,
> + 0x1a, 0x44, 0xbe, 0x62, 0xed, 0x90, 0xc4, 0xd1
> +};
> +enum { nonce63 = 0xe8e849596c942276ULL };
> +
> +static const u8 input64[] __initconst = {
> + 0x84, 0xf8, 0xda, 0x87, 0x23, 0x39, 0x60, 0xcf,
> + 0xc5, 0x50, 0x7e, 0xc5, 0x47, 0x29, 0x7c, 0x05,
> + 0xc2, 0xb4, 0xf4, 0xb2, 0xec, 0x5d, 0x48, 0x36,
> + 0xbf, 0xfc, 0x06, 0x8c, 0xf2, 0x0e, 0x88, 0xe7,
> + 0xc9, 0xc5, 0xa4, 0xa2, 0x83, 0x20, 0xa1, 0x6f,
> + 0x37, 0xe5, 0x2d, 0xa1, 0x72, 0xa1, 0x19, 0xef,
> + 0x05, 0x42, 0x08, 0xf2, 0x57, 0x47, 0x31, 0x1e,
> + 0x17, 0x76, 0x13, 0xd3, 0xcc, 0x75, 0x2c
> +};
> +static const u8 output64[] __initconst = {
> + 0xcb, 0xec, 0x90, 0x88, 0xeb, 0x31, 0x69, 0x20,
> + 0xa6, 0xdc, 0xff, 0x76, 0x98, 0xb0, 0x24, 0x49,
> + 0x7b, 0x20, 0xd9, 0xd1, 0x1b, 0xe3, 0x61, 0xdc,
> + 0xcf, 0x51, 0xf6, 0x70, 0x72, 0x33, 0x28, 0x94,
> + 0xac, 0x73, 0x18, 0xcf, 0x93, 0xfd, 0xca, 0x08,
> + 0x0d, 0xa2, 0xb9, 0x57, 0x1e, 0x51, 0xb6, 0x07,
> + 0x5c, 0xc1, 0x13, 0x64, 0x1d, 0x18, 0x6f, 0xe6,
> + 0x0b, 0xb7, 0x14, 0x03, 0x43, 0xb6, 0xaf
> +};
> +static const u8 key64[] __initconst = {
> + 0xbf, 0x82, 0x65, 0xe4, 0x50, 0xf9, 0x5e, 0xea,
> + 0x28, 0x91, 0xd1, 0xd2, 0x17, 0x7c, 0x13, 0x7e,
> + 0xf5, 0xd5, 0x6b, 0x06, 0x1c, 0x20, 0xc2, 0x82,
> + 0xa1, 0x7a, 0xa2, 0x14, 0xa1, 0xb0, 0x54, 0x58
> +};
> +enum { nonce64 = 0xe57c5095aa5723c9ULL };
> +
> +static const u8 input65[] __initconst = {
> + 0x1c, 0xfb, 0xd3, 0x3f, 0x85, 0xd7, 0xba, 0x7b,
> + 0xae, 0xb1, 0xa5, 0xd2, 0xe5, 0x40, 0xce, 0x4d,
> + 0x3e, 0xab, 0x17, 0x9d, 0x7d, 0x9f, 0x03, 0x98,
> + 0x3f, 0x9f, 0xc8, 0xdd, 0x36, 0x17, 0x43, 0x5c,
> + 0x34, 0xd1, 0x23, 0xe0, 0x77, 0xbf, 0x35, 0x5d,
> + 0x8f, 0xb1, 0xcb, 0x82, 0xbb, 0x39, 0x69, 0xd8,
> + 0x90, 0x45, 0x37, 0xfd, 0x98, 0x25, 0xf7, 0x5b,
> + 0xce, 0x06, 0x43, 0xba, 0x61, 0xa8, 0x47, 0xb9
> +};
> +static const u8 output65[] __initconst = {
> + 0x73, 0xa5, 0x68, 0xab, 0x8b, 0xa5, 0xc3, 0x7e,
> + 0x74, 0xf8, 0x9d, 0xf5, 0x93, 0x6e, 0xf2, 0x71,
> + 0x6d, 0xde, 0x82, 0xc5, 0x40, 0xa0, 0x46, 0xb3,
> + 0x9a, 0x78, 0xa8, 0xf7, 0xdf, 0xb1, 0xc3, 0xdd,
> + 0x8d, 0x90, 0x00, 0x68, 0x21, 0x48, 0xe8, 0xba,
> + 0x56, 0x9f, 0x8f, 0xe7, 0xa4, 0x4d, 0x36, 0x55,
> + 0xd0, 0x34, 0x99, 0xa6, 0x1c, 0x4c, 0xc1, 0xe2,
> + 0x65, 0x98, 0x14, 0x8e, 0x6a, 0x05, 0xb1, 0x2b
> +};
> +static const u8 key65[] __initconst = {
> + 0xbd, 0x5c, 0x8a, 0xb0, 0x11, 0x29, 0xf3, 0x00,
> + 0x7a, 0x78, 0x32, 0x63, 0x34, 0x00, 0xe6, 0x7d,
> + 0x30, 0x54, 0xde, 0x37, 0xda, 0xc2, 0xc4, 0x3d,
> + 0x92, 0x6b, 0x4c, 0xc2, 0x92, 0xe9, 0x9e, 0x2a
> +};
> +enum { nonce65 = 0xf654a3031de746f2ULL };
> +
> +static const u8 input66[] __initconst = {
> + 0x4b, 0x27, 0x30, 0x8f, 0x28, 0xd8, 0x60, 0x46,
> + 0x39, 0x06, 0x49, 0xea, 0x1b, 0x71, 0x26, 0xe0,
> + 0x99, 0x2b, 0xd4, 0x8f, 0x64, 0x64, 0xcd, 0xac,
> + 0x1d, 0x78, 0x88, 0x90, 0xe1, 0x5c, 0x24, 0x4b,
> + 0xdc, 0x2d, 0xb7, 0xee, 0x3a, 0xe6, 0x86, 0x2c,
> + 0x21, 0xe4, 0x2b, 0xfc, 0xe8, 0x19, 0xca, 0x65,
> + 0xe7, 0xdd, 0x6f, 0x52, 0xb3, 0x11, 0xe1, 0xe2,
> + 0xbf, 0xe8, 0x70, 0xe3, 0x0d, 0x45, 0xb8, 0xa5,
> + 0x20, 0xb7, 0xb5, 0xaf, 0xff, 0x08, 0xcf, 0x23,
> + 0x65, 0xdf, 0x8d, 0xc3, 0x31, 0xf3, 0x1e, 0x6a,
> + 0x58, 0x8d, 0xcc, 0x45, 0x16, 0x86, 0x1f, 0x31,
> + 0x5c, 0x27, 0xcd, 0xc8, 0x6b, 0x19, 0x1e, 0xec,
> + 0x44, 0x75, 0x63, 0x97, 0xfd, 0x79, 0xf6, 0x62,
> + 0xc5, 0xba, 0x17, 0xc7, 0xab, 0x8f, 0xbb, 0xed,
> + 0x85, 0x2a, 0x98, 0x79, 0x21, 0xec, 0x6e, 0x4d,
> + 0xdc, 0xfa, 0x72, 0x52, 0xba, 0xc8, 0x4c
> +};
> +static const u8 output66[] __initconst = {
> + 0x76, 0x5b, 0x2c, 0xa7, 0x62, 0xb9, 0x08, 0x4a,
> + 0xc6, 0x4a, 0x92, 0xc3, 0xbb, 0x10, 0xb3, 0xee,
> + 0xff, 0xb9, 0x07, 0xc7, 0x27, 0xcb, 0x1e, 0xcf,
> + 0x58, 0x6f, 0xa1, 0x64, 0xe8, 0xf1, 0x4e, 0xe1,
> + 0xef, 0x18, 0x96, 0xab, 0x97, 0x28, 0xd1, 0x7c,
> + 0x71, 0x6c, 0xd1, 0xe2, 0xfa, 0xd9, 0x75, 0xcb,
> + 0xeb, 0xea, 0x0c, 0x86, 0x82, 0xd8, 0xf4, 0xcc,
> + 0xea, 0xa3, 0x00, 0xfa, 0x82, 0xd2, 0xcd, 0xcb,
> + 0xdb, 0x63, 0x28, 0xe2, 0x82, 0xe9, 0x01, 0xed,
> + 0x31, 0xe6, 0x71, 0x45, 0x08, 0x89, 0x8a, 0x23,
> + 0xa8, 0xb5, 0xc2, 0xe2, 0x9f, 0xe9, 0xb8, 0x9a,
> + 0xc4, 0x79, 0x6d, 0x71, 0x52, 0x61, 0x74, 0x6c,
> + 0x1b, 0xd7, 0x65, 0x6d, 0x03, 0xc4, 0x1a, 0xc0,
> + 0x50, 0xba, 0xd6, 0xc9, 0x43, 0x50, 0xbe, 0x09,
> + 0x09, 0x8a, 0xdb, 0xaa, 0x76, 0x4e, 0x3b, 0x61,
> + 0x3c, 0x7c, 0x44, 0xe7, 0xdb, 0x10, 0xa7
> +};
> +static const u8 key66[] __initconst = {
> + 0x88, 0xdf, 0xca, 0x68, 0xaf, 0x4f, 0xb3, 0xfd,
> + 0x6e, 0xa7, 0x95, 0x35, 0x8a, 0xe8, 0x37, 0xe8,
> + 0xc8, 0x55, 0xa2, 0x2a, 0x6d, 0x77, 0xf8, 0x93,
> + 0x7a, 0x41, 0xf3, 0x7b, 0x95, 0xdf, 0x89, 0xf5
> +};
> +enum { nonce66 = 0x1024b4fdd415cf82ULL };
> +
> +static const u8 input67[] __initconst = {
> + 0xd4, 0x2e, 0xfa, 0x92, 0xe9, 0x29, 0x68, 0xb7,
> + 0x54, 0x2c, 0xf7, 0xa4, 0x2d, 0xb7, 0x50, 0xb5,
> + 0xc5, 0xb2, 0x9d, 0x17, 0x5e, 0x0a, 0xca, 0x37,
> + 0xbf, 0x60, 0xae, 0xd2, 0x98, 0xe9, 0xfa, 0x59,
> + 0x67, 0x62, 0xe6, 0x43, 0x0c, 0x77, 0x80, 0x82,
> + 0x33, 0x61, 0xa3, 0xff, 0xc1, 0xa0, 0x8f, 0x56,
> + 0xbc, 0xec, 0x65, 0x43, 0x88, 0xa5, 0xff, 0x51,
> + 0x64, 0x30, 0xee, 0x34, 0xb7, 0x5c, 0x28, 0x68,
> + 0xc3, 0x52, 0xd2, 0xac, 0x78, 0x2a, 0xa6, 0x10,
> + 0xb8, 0xb2, 0x4c, 0x80, 0x4f, 0x99, 0xb2, 0x36,
> + 0x94, 0x8f, 0x66, 0xcb, 0xa1, 0x91, 0xed, 0x06,
> + 0x42, 0x6d, 0xc1, 0xae, 0x55, 0x93, 0xdd, 0x93,
> + 0x9e, 0x88, 0x34, 0x7f, 0x98, 0xeb, 0xbe, 0x61,
> + 0xf9, 0xa9, 0x0f, 0xd9, 0xc4, 0x87, 0xd5, 0xef,
> + 0xcc, 0x71, 0x8c, 0x0e, 0xce, 0xad, 0x02, 0xcf,
> + 0xa2, 0x61, 0xdf, 0xb1, 0xfe, 0x3b, 0xdc, 0xc0,
> + 0x58, 0xb5, 0x71, 0xa1, 0x83, 0xc9, 0xb4, 0xaf,
> + 0x9d, 0x54, 0x12, 0xcd, 0xea, 0x06, 0xd6, 0x4e,
> + 0xe5, 0x27, 0x0c, 0xc3, 0xbb, 0xa8, 0x0a, 0x81,
> + 0x75, 0xc3, 0xc9, 0xd4, 0x35, 0x3e, 0x53, 0x9f,
> + 0xaa, 0x20, 0xc0, 0x68, 0x39, 0x2c, 0x96, 0x39,
> + 0x53, 0x81, 0xda, 0x07, 0x0f, 0x44, 0xa5, 0x47,
> + 0x0e, 0xb3, 0x87, 0x0d, 0x1b, 0xc1, 0xe5, 0x41,
> + 0x35, 0x12, 0x58, 0x96, 0x69, 0x8a, 0x1a, 0xa3,
> + 0x9d, 0x3d, 0xd4, 0xb1, 0x8e, 0x1f, 0x96, 0x87,
> + 0xda, 0xd3, 0x19, 0xe2, 0xb1, 0x3a, 0x19, 0x74,
> + 0xa0, 0x00, 0x9f, 0x4d, 0xbc, 0xcb, 0x0c, 0xe9,
> + 0xec, 0x10, 0xdf, 0x2a, 0x88, 0xdc, 0x30, 0x51,
> + 0x46, 0x56, 0x53, 0x98, 0x6a, 0x26, 0x14, 0x05,
> + 0x54, 0x81, 0x55, 0x0b, 0x3c, 0x85, 0xdd, 0x33,
> + 0x81, 0x11, 0x29, 0x82, 0x46, 0x35, 0xe1, 0xdb,
> + 0x59, 0x7b
> +};
> +static const u8 output67[] __initconst = {
> + 0x64, 0x6c, 0xda, 0x7f, 0xd4, 0xa9, 0x2a, 0x5e,
> + 0x22, 0xae, 0x8d, 0x67, 0xdb, 0xee, 0xfd, 0xd0,
> + 0x44, 0x80, 0x17, 0xb2, 0xe3, 0x87, 0xad, 0x57,
> + 0x15, 0xcb, 0x88, 0x64, 0xc0, 0xf1, 0x49, 0x3d,
> + 0xfa, 0xbe, 0xa8, 0x9f, 0x12, 0xc3, 0x57, 0x56,
> + 0x70, 0xa5, 0xc5, 0x6b, 0xf1, 0xab, 0xd5, 0xde,
> + 0x77, 0x92, 0x6a, 0x56, 0x03, 0xf5, 0x21, 0x0d,
> + 0xb6, 0xc4, 0xcc, 0x62, 0x44, 0x3f, 0xb1, 0xc1,
> + 0x61, 0x41, 0x90, 0xb2, 0xd5, 0xb8, 0xf3, 0x57,
> + 0xfb, 0xc2, 0x6b, 0x25, 0x58, 0xc8, 0x45, 0x20,
> + 0x72, 0x29, 0x6f, 0x9d, 0xb5, 0x81, 0x4d, 0x2b,
> + 0xb2, 0x89, 0x9e, 0x91, 0x53, 0x97, 0x1c, 0xd9,
> + 0x3d, 0x79, 0xdc, 0x14, 0xae, 0x01, 0x73, 0x75,
> + 0xf0, 0xca, 0xd5, 0xab, 0x62, 0x5c, 0x7a, 0x7d,
> + 0x3f, 0xfe, 0x22, 0x7d, 0xee, 0xe2, 0xcb, 0x76,
> + 0x55, 0xec, 0x06, 0xdd, 0x41, 0x47, 0x18, 0x62,
> + 0x1d, 0x57, 0xd0, 0xd6, 0xb6, 0x0f, 0x4b, 0xfc,
> + 0x79, 0x19, 0xf4, 0xd6, 0x37, 0x86, 0x18, 0x1f,
> + 0x98, 0x0d, 0x9e, 0x15, 0x2d, 0xb6, 0x9a, 0x8a,
> + 0x8c, 0x80, 0x22, 0x2f, 0x82, 0xc4, 0xc7, 0x36,
> + 0xfa, 0xfa, 0x07, 0xbd, 0xc2, 0x2a, 0xe2, 0xea,
> + 0x93, 0xc8, 0xb2, 0x90, 0x33, 0xf2, 0xee, 0x4b,
> + 0x1b, 0xf4, 0x37, 0x92, 0x13, 0xbb, 0xe2, 0xce,
> + 0xe3, 0x03, 0xcf, 0x07, 0x94, 0xab, 0x9a, 0xc9,
> + 0xff, 0x83, 0x69, 0x3a, 0xda, 0x2c, 0xd0, 0x47,
> + 0x3d, 0x6c, 0x1a, 0x60, 0x68, 0x47, 0xb9, 0x36,
> + 0x52, 0xdd, 0x16, 0xef, 0x6c, 0xbf, 0x54, 0x11,
> + 0x72, 0x62, 0xce, 0x8c, 0x9d, 0x90, 0xa0, 0x25,
> + 0x06, 0x92, 0x3e, 0x12, 0x7e, 0x1a, 0x1d, 0xe5,
> + 0xa2, 0x71, 0xce, 0x1c, 0x4c, 0x6a, 0x7c, 0xdc,
> + 0x3d, 0xe3, 0x6e, 0x48, 0x9d, 0xb3, 0x64, 0x7d,
> + 0x78, 0x40
> +};
> +static const u8 key67[] __initconst = {
> + 0xa9, 0x20, 0x75, 0x89, 0x7e, 0x37, 0x85, 0x48,
> + 0xa3, 0xfb, 0x7b, 0xe8, 0x30, 0xa7, 0xe3, 0x6e,
> + 0xa6, 0xc1, 0x71, 0x17, 0xc1, 0x6c, 0x9b, 0xc2,
> + 0xde, 0xf0, 0xa7, 0x19, 0xec, 0xce, 0xc6, 0x53
> +};
> +enum { nonce67 = 0x4adc4d1f968c8a10ULL };
> +
> +static const u8 input68[] __initconst = {
> + 0x99, 0xae, 0x72, 0xfb, 0x16, 0xe1, 0xf1, 0x59,
> + 0x43, 0x15, 0x4e, 0x33, 0xa0, 0x95, 0xe7, 0x6c,
> + 0x74, 0x24, 0x31, 0xca, 0x3b, 0x2e, 0xeb, 0xd7,
> + 0x11, 0xd8, 0xe0, 0x56, 0x92, 0x91, 0x61, 0x57,
> + 0xe2, 0x82, 0x9f, 0x8f, 0x37, 0xf5, 0x3d, 0x24,
> + 0x92, 0x9d, 0x87, 0x00, 0x8d, 0x89, 0xe0, 0x25,
> + 0x8b, 0xe4, 0x20, 0x5b, 0x8a, 0x26, 0x2c, 0x61,
> + 0x78, 0xb0, 0xa6, 0x3e, 0x82, 0x18, 0xcf, 0xdc,
> + 0x2d, 0x24, 0xdd, 0x81, 0x42, 0xc4, 0x95, 0xf0,
> + 0x48, 0x60, 0x71, 0xe3, 0xe3, 0xac, 0xec, 0xbe,
> + 0x98, 0x6b, 0x0c, 0xb5, 0x6a, 0xa9, 0xc8, 0x79,
> + 0x23, 0x2e, 0x38, 0x0b, 0x72, 0x88, 0x8c, 0xe7,
> + 0x71, 0x8b, 0x36, 0xe3, 0x58, 0x3d, 0x9c, 0xa0,
> + 0xa2, 0xea, 0xcf, 0x0c, 0x6a, 0x6c, 0x64, 0xdf,
> + 0x97, 0x21, 0x8f, 0x93, 0xfb, 0xba, 0xf3, 0x5a,
> + 0xd7, 0x8f, 0xa6, 0x37, 0x15, 0x50, 0x43, 0x02,
> + 0x46, 0x7f, 0x93, 0x46, 0x86, 0x31, 0xe2, 0xaa,
> + 0x24, 0xa8, 0x26, 0xae, 0xe6, 0xc0, 0x05, 0x73,
> + 0x0b, 0x4f, 0x7e, 0xed, 0x65, 0xeb, 0x56, 0x1e,
> + 0xb6, 0xb3, 0x0b, 0xc3, 0x0e, 0x31, 0x95, 0xa9,
> + 0x18, 0x4d, 0xaf, 0x38, 0xd7, 0xec, 0xc6, 0x44,
> + 0x72, 0x77, 0x4e, 0x25, 0x4b, 0x25, 0xdd, 0x1e,
> + 0x8c, 0xa2, 0xdf, 0xf6, 0x2a, 0x97, 0x1a, 0x88,
> + 0x2c, 0x8a, 0x5d, 0xfe, 0xe8, 0xfb, 0x35, 0xe8,
> + 0x0f, 0x2b, 0x7a, 0x18, 0x69, 0x43, 0x31, 0x1d,
> + 0x38, 0x6a, 0x62, 0x95, 0x0f, 0x20, 0x4b, 0xbb,
> + 0x97, 0x3c, 0xe0, 0x64, 0x2f, 0x52, 0xc9, 0x2d,
> + 0x4d, 0x9d, 0x54, 0x04, 0x3d, 0xc9, 0xea, 0xeb,
> + 0xd0, 0x86, 0x52, 0xff, 0x42, 0xe1, 0x0d, 0x7a,
> + 0xad, 0x88, 0xf9, 0x9b, 0x1e, 0x5e, 0x12, 0x27,
> + 0x95, 0x3e, 0x0c, 0x2c, 0x13, 0x00, 0x6f, 0x8e,
> + 0x93, 0x69, 0x0e, 0x01, 0x8c, 0xc1, 0xfd, 0xb3
> +};
> +static const u8 output68[] __initconst = {
> + 0x26, 0x3e, 0xf2, 0xb1, 0xf5, 0xef, 0x81, 0xa4,
> + 0xb7, 0x42, 0xd4, 0x26, 0x18, 0x4b, 0xdd, 0x6a,
> + 0x47, 0x15, 0xcb, 0x0e, 0x57, 0xdb, 0xa7, 0x29,
> + 0x7e, 0x7b, 0x3f, 0x47, 0x89, 0x57, 0xab, 0xea,
> + 0x14, 0x7b, 0xcf, 0x37, 0xdb, 0x1c, 0xe1, 0x11,
> + 0x77, 0xae, 0x2e, 0x4c, 0xd2, 0x08, 0x3f, 0xa6,
> + 0x62, 0x86, 0xa6, 0xb2, 0x07, 0xd5, 0x3f, 0x9b,
> + 0xdc, 0xc8, 0x50, 0x4b, 0x7b, 0xb9, 0x06, 0xe6,
> + 0xeb, 0xac, 0x98, 0x8c, 0x36, 0x0c, 0x1e, 0xb2,
> + 0xc8, 0xfb, 0x24, 0x60, 0x2c, 0x08, 0x17, 0x26,
> + 0x5b, 0xc8, 0xc2, 0xdf, 0x9c, 0x73, 0x67, 0x4a,
> + 0xdb, 0xcf, 0xd5, 0x2c, 0x2b, 0xca, 0x24, 0xcc,
> + 0xdb, 0xc9, 0xa8, 0xf2, 0x5d, 0x67, 0xdf, 0x5c,
> + 0x62, 0x0b, 0x58, 0xc0, 0x83, 0xde, 0x8b, 0xf6,
> + 0x15, 0x0a, 0xd6, 0x32, 0xd8, 0xf5, 0xf2, 0x5f,
> + 0x33, 0xce, 0x7e, 0xab, 0x76, 0xcd, 0x14, 0x91,
> + 0xd8, 0x41, 0x90, 0x93, 0xa1, 0xaf, 0xf3, 0x45,
> + 0x6c, 0x1b, 0x25, 0xbd, 0x48, 0x51, 0x6d, 0x15,
> + 0x47, 0xe6, 0x23, 0x50, 0x32, 0x69, 0x1e, 0xb5,
> + 0x94, 0xd3, 0x97, 0xba, 0xd7, 0x37, 0x4a, 0xba,
> + 0xb9, 0xcd, 0xfb, 0x96, 0x9a, 0x90, 0xe0, 0x37,
> + 0xf8, 0xdf, 0x91, 0x6c, 0x62, 0x13, 0x19, 0x21,
> + 0x4b, 0xa9, 0xf1, 0x12, 0x66, 0xe2, 0x74, 0xd7,
> + 0x81, 0xa0, 0x74, 0x8d, 0x7e, 0x7e, 0xc9, 0xb1,
> + 0x69, 0x8f, 0xed, 0xb3, 0xf6, 0x97, 0xcd, 0x72,
> + 0x78, 0x93, 0xd3, 0x54, 0x6b, 0x43, 0xac, 0x29,
> + 0xb4, 0xbc, 0x7d, 0xa4, 0x26, 0x4b, 0x7b, 0xab,
> + 0xd6, 0x67, 0x22, 0xff, 0x03, 0x92, 0xb6, 0xd4,
> + 0x96, 0x94, 0x5a, 0xe5, 0x02, 0x35, 0x77, 0xfa,
> + 0x3f, 0x54, 0x1d, 0xdd, 0x35, 0x39, 0xfe, 0x03,
> + 0xdd, 0x8e, 0x3c, 0x8c, 0xc2, 0x69, 0x2a, 0xb1,
> + 0xb7, 0xb3, 0xa1, 0x89, 0x84, 0xea, 0x16, 0xe2
> +};
> +static const u8 key68[] __initconst = {
> + 0xd2, 0x49, 0x7f, 0xd7, 0x49, 0x66, 0x0d, 0xb3,
> + 0x5a, 0x7e, 0x3c, 0xfc, 0x37, 0x83, 0x0e, 0xf7,
> + 0x96, 0xd8, 0xd6, 0x33, 0x79, 0x2b, 0x84, 0x53,
> + 0x06, 0xbc, 0x6c, 0x0a, 0x55, 0x84, 0xfe, 0xab
> +};
> +enum { nonce68 = 0x6a6df7ff0a20de06ULL };
> +
> +static const u8 input69[] __initconst = {
> + 0xf9, 0x18, 0x4c, 0xd2, 0x3f, 0xf7, 0x22, 0xd9,
> + 0x58, 0xb6, 0x3b, 0x38, 0x69, 0x79, 0xf4, 0x71,
> + 0x5f, 0x38, 0x52, 0x1f, 0x17, 0x6f, 0x6f, 0xd9,
> + 0x09, 0x2b, 0xfb, 0x67, 0xdc, 0xc9, 0xe8, 0x4a,
> + 0x70, 0x9f, 0x2e, 0x3c, 0x06, 0xe5, 0x12, 0x20,
> + 0x25, 0x29, 0xd0, 0xdc, 0x81, 0xc5, 0xc6, 0x0f,
> + 0xd2, 0xa8, 0x81, 0x15, 0x98, 0xb2, 0x71, 0x5a,
> + 0x9a, 0xe9, 0xfb, 0xaf, 0x0e, 0x5f, 0x8a, 0xf3,
> + 0x16, 0x4a, 0x47, 0xf2, 0x5c, 0xbf, 0xda, 0x52,
> + 0x9a, 0xa6, 0x36, 0xfd, 0xc6, 0xf7, 0x66, 0x00,
> + 0xcc, 0x6c, 0xd4, 0xb3, 0x07, 0x6d, 0xeb, 0xfe,
> + 0x92, 0x71, 0x25, 0xd0, 0xcf, 0x9c, 0xe8, 0x65,
> + 0x45, 0x10, 0xcf, 0x62, 0x74, 0x7d, 0xf2, 0x1b,
> + 0x57, 0xa0, 0xf1, 0x6b, 0xa4, 0xd5, 0xfa, 0x12,
> + 0x27, 0x5a, 0xf7, 0x99, 0xfc, 0xca, 0xf3, 0xb8,
> + 0x2c, 0x8b, 0xba, 0x28, 0x74, 0xde, 0x8f, 0x78,
> + 0xa2, 0x8c, 0xaf, 0x89, 0x4b, 0x05, 0xe2, 0xf3,
> + 0xf8, 0xd2, 0xef, 0xac, 0xa4, 0xc4, 0xe2, 0xe2,
> + 0x36, 0xbb, 0x5e, 0xae, 0xe6, 0x87, 0x3d, 0x88,
> + 0x9f, 0xb8, 0x11, 0xbb, 0xcf, 0x57, 0xce, 0xd0,
> + 0xba, 0x62, 0xf4, 0xf8, 0x9b, 0x95, 0x04, 0xc9,
> + 0xcf, 0x01, 0xe9, 0xf1, 0xc8, 0xc6, 0x22, 0xa4,
> + 0xf2, 0x8b, 0x2f, 0x24, 0x0a, 0xf5, 0x6e, 0xb7,
> + 0xd4, 0x2c, 0xb6, 0xf7, 0x5c, 0x97, 0x61, 0x0b,
> + 0xd9, 0xb5, 0x06, 0xcd, 0xed, 0x3e, 0x1f, 0xc5,
> + 0xb2, 0x6c, 0xa3, 0xea, 0xb8, 0xad, 0xa6, 0x42,
> + 0x88, 0x7a, 0x52, 0xd5, 0x64, 0xba, 0xb5, 0x20,
> + 0x10, 0xa0, 0x0f, 0x0d, 0xea, 0xef, 0x5a, 0x9b,
> + 0x27, 0xb8, 0xca, 0x20, 0x19, 0x6d, 0xa8, 0xc4,
> + 0x46, 0x04, 0xb3, 0xe8, 0xf8, 0x66, 0x1b, 0x0a,
> + 0xce, 0x76, 0x5d, 0x59, 0x58, 0x05, 0xee, 0x3e,
> + 0x3c, 0x86, 0x5b, 0x49, 0x1c, 0x72, 0x18, 0x01,
> + 0x62, 0x92, 0x0f, 0x3e, 0xd1, 0x57, 0x5e, 0x20,
> + 0x7b, 0xfb, 0x4d, 0x3c, 0xc5, 0x35, 0x43, 0x2f,
> + 0xb0, 0xc5, 0x7c, 0xe4, 0xa2, 0x84, 0x13, 0x77
> +};
> +static const u8 output69[] __initconst = {
> + 0xbb, 0x4a, 0x7f, 0x7c, 0xd5, 0x2f, 0x89, 0x06,
> + 0xec, 0x20, 0xf1, 0x9a, 0x11, 0x09, 0x14, 0x2e,
> + 0x17, 0x50, 0xf9, 0xd5, 0xf5, 0x48, 0x7c, 0x7a,
> + 0x55, 0xc0, 0x57, 0x03, 0xe3, 0xc4, 0xb2, 0xb7,
> + 0x18, 0x47, 0x95, 0xde, 0xaf, 0x80, 0x06, 0x3c,
> + 0x5a, 0xf2, 0xc3, 0x53, 0xe3, 0x29, 0x92, 0xf8,
> + 0xff, 0x64, 0x85, 0xb9, 0xf7, 0xd3, 0x80, 0xd2,
> + 0x0c, 0x5d, 0x7b, 0x57, 0x0c, 0x51, 0x79, 0x86,
> + 0xf3, 0x20, 0xd2, 0xb8, 0x6e, 0x0c, 0x5a, 0xce,
> + 0xeb, 0x88, 0x02, 0x8b, 0x82, 0x1b, 0x7f, 0xf5,
> + 0xde, 0x7f, 0x48, 0x48, 0xdf, 0xa0, 0x55, 0xc6,
> + 0x0c, 0x22, 0xa1, 0x80, 0x8d, 0x3b, 0xcb, 0x40,
> + 0x2d, 0x3d, 0x0b, 0xf2, 0xe0, 0x22, 0x13, 0x99,
> + 0xe1, 0xa7, 0x27, 0x68, 0x31, 0xe1, 0x24, 0x5d,
> + 0xd2, 0xee, 0x16, 0xc1, 0xd7, 0xa8, 0x14, 0x19,
> + 0x23, 0x72, 0x67, 0x27, 0xdc, 0x5e, 0xb9, 0xc7,
> + 0xd8, 0xe3, 0x55, 0x50, 0x40, 0x98, 0x7b, 0xe7,
> + 0x34, 0x1c, 0x3b, 0x18, 0x14, 0xd8, 0x62, 0xc1,
> + 0x93, 0x84, 0xf3, 0x5b, 0xdd, 0x9e, 0x1f, 0x3b,
> + 0x0b, 0xbc, 0x4e, 0x5b, 0x79, 0xa3, 0xca, 0x74,
> + 0x2a, 0x98, 0xe8, 0x04, 0x39, 0xef, 0xc6, 0x76,
> + 0x6d, 0xee, 0x9f, 0x67, 0x5b, 0x59, 0x3a, 0xe5,
> + 0xf2, 0x3b, 0xca, 0x89, 0xe8, 0x9b, 0x03, 0x3d,
> + 0x11, 0xd2, 0x4a, 0x70, 0xaf, 0x88, 0xb0, 0x94,
> + 0x96, 0x26, 0xab, 0x3c, 0xc1, 0xb8, 0xe4, 0xe7,
> + 0x14, 0x61, 0x64, 0x3a, 0x61, 0x08, 0x0f, 0xa9,
> + 0xce, 0x64, 0xb2, 0x40, 0xf8, 0x20, 0x3a, 0xa9,
> + 0x31, 0xbd, 0x7e, 0x16, 0xca, 0xf5, 0x62, 0x0f,
> + 0x91, 0x9f, 0x8e, 0x1d, 0xa4, 0x77, 0xf3, 0x87,
> + 0x61, 0xe8, 0x14, 0xde, 0x18, 0x68, 0x4e, 0x9d,
> + 0x73, 0xcd, 0x8a, 0xe4, 0x80, 0x84, 0x23, 0xaa,
> + 0x9d, 0x64, 0x1c, 0x80, 0x41, 0xca, 0x82, 0x40,
> + 0x94, 0x55, 0xe3, 0x28, 0xa1, 0x97, 0x71, 0xba,
> + 0xf2, 0x2c, 0x39, 0x62, 0x29, 0x56, 0xd0, 0xff,
> + 0xb2, 0x82, 0x20, 0x59, 0x1f, 0xc3, 0x64, 0x57
> +};
> +static const u8 key69[] __initconst = {
> + 0x19, 0x09, 0xe9, 0x7c, 0xd9, 0x02, 0x4a, 0x0c,
> + 0x52, 0x25, 0xad, 0x5c, 0x2e, 0x8d, 0x86, 0x10,
> + 0x85, 0x2b, 0xba, 0xa4, 0x44, 0x5b, 0x39, 0x3e,
> + 0x18, 0xaa, 0xce, 0x0e, 0xe2, 0x69, 0x3c, 0xcf
> +};
> +enum { nonce69 = 0xdb925a1948f0f060ULL };
> +
> +static const u8 input70[] __initconst = {
> + 0x10, 0xe7, 0x83, 0xcf, 0x42, 0x9f, 0xf2, 0x41,
> + 0xc7, 0xe4, 0xdb, 0xf9, 0xa3, 0x02, 0x1d, 0x8d,
> + 0x50, 0x81, 0x2c, 0x6b, 0x92, 0xe0, 0x4e, 0xea,
> + 0x26, 0x83, 0x2a, 0xd0, 0x31, 0xf1, 0x23, 0xf3,
> + 0x0e, 0x88, 0x14, 0x31, 0xf9, 0x01, 0x63, 0x59,
> + 0x21, 0xd1, 0x8b, 0xdd, 0x06, 0xd0, 0xc6, 0xab,
> + 0x91, 0x71, 0x82, 0x4d, 0xd4, 0x62, 0x37, 0x17,
> + 0xf9, 0x50, 0xf9, 0xb5, 0x74, 0xce, 0x39, 0x80,
> + 0x80, 0x78, 0xf8, 0xdc, 0x1c, 0xdb, 0x7c, 0x3d,
> + 0xd4, 0x86, 0x31, 0x00, 0x75, 0x7b, 0xd1, 0x42,
> + 0x9f, 0x1b, 0x97, 0x88, 0x0e, 0x14, 0x0e, 0x1e,
> + 0x7d, 0x7b, 0xc4, 0xd2, 0xf3, 0xc1, 0x6d, 0x17,
> + 0x5d, 0xc4, 0x75, 0x54, 0x0f, 0x38, 0x65, 0x89,
> + 0xd8, 0x7d, 0xab, 0xc9, 0xa7, 0x0a, 0x21, 0x0b,
> + 0x37, 0x12, 0x05, 0x07, 0xb5, 0x68, 0x32, 0x32,
> + 0xb9, 0xf8, 0x97, 0x17, 0x03, 0xed, 0x51, 0x8f,
> + 0x3d, 0x5a, 0xd0, 0x12, 0x01, 0x6e, 0x2e, 0x91,
> + 0x1c, 0xbe, 0x6b, 0xa3, 0xcc, 0x75, 0x62, 0x06,
> + 0x8e, 0x65, 0xbb, 0xe2, 0x29, 0x71, 0x4b, 0x89,
> + 0x6a, 0x9d, 0x85, 0x8c, 0x8c, 0xdf, 0x94, 0x95,
> + 0x23, 0x66, 0xf8, 0x92, 0xee, 0x56, 0xeb, 0xb3,
> + 0xeb, 0xd2, 0x4a, 0x3b, 0x77, 0x8a, 0x6e, 0xf6,
> + 0xca, 0xd2, 0x34, 0x00, 0xde, 0xbe, 0x1d, 0x7a,
> + 0x73, 0xef, 0x2b, 0x80, 0x56, 0x16, 0x29, 0xbf,
> + 0x6e, 0x33, 0xed, 0x0d, 0xe2, 0x02, 0x60, 0x74,
> + 0xe9, 0x0a, 0xbc, 0xd1, 0xc5, 0xe8, 0x53, 0x02,
> + 0x79, 0x0f, 0x25, 0x0c, 0xef, 0xab, 0xd3, 0xbc,
> + 0xb7, 0xfc, 0xf3, 0xb0, 0x34, 0xd1, 0x07, 0xd2,
> + 0x5a, 0x31, 0x1f, 0xec, 0x1f, 0x87, 0xed, 0xdd,
> + 0x6a, 0xc1, 0xe8, 0xb3, 0x25, 0x4c, 0xc6, 0x9b,
> + 0x91, 0x73, 0xec, 0x06, 0x73, 0x9e, 0x57, 0x65,
> + 0x32, 0x75, 0x11, 0x74, 0x6e, 0xa4, 0x7d, 0x0d,
> + 0x74, 0x9f, 0x51, 0x10, 0x10, 0x47, 0xc9, 0x71,
> + 0x6e, 0x97, 0xae, 0x44, 0x41, 0xef, 0x98, 0x78,
> + 0xf4, 0xc5, 0xbd, 0x5e, 0x00, 0xe5, 0xfd, 0xe2,
> + 0xbe, 0x8c, 0xc2, 0xae, 0xc2, 0xee, 0x59, 0xf6,
> + 0xcb, 0x20, 0x54, 0x84, 0xc3, 0x31, 0x7e, 0x67,
> + 0x71, 0xb6, 0x76, 0xbe, 0x81, 0x8f, 0x82, 0xad,
> + 0x01, 0x8f, 0xc4, 0x00, 0x04, 0x3d, 0x8d, 0x34,
> + 0xaa, 0xea, 0xc0, 0xea, 0x91, 0x42, 0xb6, 0xb8,
> + 0x43, 0xf3, 0x17, 0xb2, 0x73, 0x64, 0x82, 0x97,
> + 0xd5, 0xc9, 0x07, 0x77, 0xb1, 0x26, 0xe2, 0x00,
> + 0x6a, 0xae, 0x70, 0x0b, 0xbe, 0xe6, 0xb8, 0x42,
> + 0x81, 0x55, 0xf7, 0xb8, 0x96, 0x41, 0x9d, 0xd4,
> + 0x2c, 0x27, 0x00, 0xcc, 0x91, 0x28, 0x22, 0xa4,
> + 0x7b, 0x42, 0x51, 0x9e, 0xd6, 0xec, 0xf3, 0x6b,
> + 0x00, 0xff, 0x5c, 0xa2, 0xac, 0x47, 0x33, 0x2d,
> + 0xf8, 0x11, 0x65, 0x5f, 0x4d, 0x79, 0x8b, 0x4f,
> + 0xad, 0xf0, 0x9d, 0xcd, 0xb9, 0x7b, 0x08, 0xf7,
> + 0x32, 0x51, 0xfa, 0x39, 0xaa, 0x78, 0x05, 0xb1,
> + 0xf3, 0x5d, 0xe8, 0x7c, 0x8e, 0x4f, 0xa2, 0xe0,
> + 0x98, 0x0c, 0xb2, 0xa7, 0xf0, 0x35, 0x8e, 0x70,
> + 0x7c, 0x82, 0xf3, 0x1b, 0x26, 0x28, 0x12, 0xe5,
> + 0x23, 0x57, 0xe4, 0xb4, 0x9b, 0x00, 0x39, 0x97,
> + 0xef, 0x7c, 0x46, 0x9b, 0x34, 0x6b, 0xe7, 0x0e,
> + 0xa3, 0x2a, 0x18, 0x11, 0x64, 0xc6, 0x7c, 0x8b,
> + 0x06, 0x02, 0xf5, 0x69, 0x76, 0xf9, 0xaa, 0x09,
> + 0x5f, 0x68, 0xf8, 0x4a, 0x79, 0x58, 0xec, 0x37,
> + 0xcf, 0x3a, 0xcc, 0x97, 0x70, 0x1d, 0x3e, 0x52,
> + 0x18, 0x0a, 0xad, 0x28, 0x5b, 0x3b, 0xe9, 0x03,
> + 0x84, 0xe9, 0x68, 0x50, 0xce, 0xc4, 0xbc, 0x3e,
> + 0x21, 0xad, 0x63, 0xfe, 0xc6, 0xfd, 0x6e, 0x69,
> + 0x84, 0xa9, 0x30, 0xb1, 0x7a, 0xc4, 0x31, 0x10,
> + 0xc1, 0x1f, 0x6e, 0xeb, 0xa5, 0xa6, 0x01
> +};
> +static const u8 output70[] __initconst = {
> + 0x0f, 0x93, 0x2a, 0x20, 0xb3, 0x87, 0x2d, 0xce,
> + 0xd1, 0x3b, 0x30, 0xfd, 0x06, 0x6d, 0x0a, 0xaa,
> + 0x3e, 0xc4, 0x29, 0x02, 0x8a, 0xde, 0xa6, 0x4b,
> + 0x45, 0x1b, 0x4f, 0x25, 0x59, 0xd5, 0x56, 0x6a,
> + 0x3b, 0x37, 0xbd, 0x3e, 0x47, 0x12, 0x2c, 0x4e,
> + 0x60, 0x5f, 0x05, 0x75, 0x61, 0x23, 0x05, 0x74,
> + 0xcb, 0xfc, 0x5a, 0xb3, 0xac, 0x5c, 0x3d, 0xab,
> + 0x52, 0x5f, 0x05, 0xbc, 0x57, 0xc0, 0x7e, 0xcf,
> + 0x34, 0x5d, 0x7f, 0x41, 0xa3, 0x17, 0x78, 0xd5,
> + 0x9f, 0xec, 0x0f, 0x1e, 0xf9, 0xfe, 0xa3, 0xbd,
> + 0x28, 0xb0, 0xba, 0x4d, 0x84, 0xdb, 0xae, 0x8f,
> + 0x1d, 0x98, 0xb7, 0xdc, 0xf9, 0xad, 0x55, 0x9c,
> + 0x89, 0xfe, 0x9b, 0x9c, 0xa9, 0x89, 0xf6, 0x97,
> + 0x9c, 0x3f, 0x09, 0x3e, 0xc6, 0x02, 0xc2, 0x55,
> + 0x58, 0x09, 0x54, 0x66, 0xe4, 0x36, 0x81, 0x35,
> + 0xca, 0x88, 0x17, 0x89, 0x80, 0x24, 0x2b, 0x21,
> + 0x89, 0xee, 0x45, 0x5a, 0xe7, 0x1f, 0xd5, 0xa5,
> + 0x16, 0xa4, 0xda, 0x70, 0x7e, 0xe9, 0x4f, 0x24,
> + 0x61, 0x97, 0xab, 0xa0, 0xe0, 0xe7, 0xb8, 0x5c,
> + 0x0f, 0x25, 0x17, 0x37, 0x75, 0x12, 0xb5, 0x40,
> + 0xde, 0x1c, 0x0d, 0x8a, 0x77, 0x62, 0x3c, 0x86,
> + 0xd9, 0x70, 0x2e, 0x96, 0x30, 0xd2, 0x55, 0xb3,
> + 0x6b, 0xc3, 0xf2, 0x9c, 0x47, 0xf3, 0x3a, 0x24,
> + 0x52, 0xc6, 0x38, 0xd8, 0x22, 0xb3, 0x0c, 0xfd,
> + 0x2f, 0xa3, 0x3c, 0xb5, 0xe8, 0x26, 0xe1, 0xa3,
> + 0xad, 0xb0, 0x82, 0x17, 0xc1, 0x53, 0xb8, 0x34,
> + 0x48, 0xee, 0x39, 0xae, 0x51, 0x43, 0xec, 0x82,
> + 0xce, 0x87, 0xc6, 0x76, 0xb9, 0x76, 0xd3, 0x53,
> + 0xfe, 0x49, 0x24, 0x7d, 0x02, 0x42, 0x2b, 0x72,
> + 0xfb, 0xcb, 0xd8, 0x96, 0x02, 0xc6, 0x9a, 0x20,
> + 0xf3, 0x5a, 0x67, 0xe8, 0x13, 0xf8, 0xb2, 0xcb,
> + 0xa2, 0xec, 0x18, 0x20, 0x4a, 0xb0, 0x73, 0x53,
> + 0x21, 0xb0, 0x77, 0x53, 0xd8, 0x76, 0xa1, 0x30,
> + 0x17, 0x72, 0x2e, 0x33, 0x5f, 0x33, 0x6b, 0x28,
> + 0xfb, 0xb0, 0xf4, 0xec, 0x8e, 0xed, 0x20, 0x7d,
> + 0x57, 0x8c, 0x74, 0x28, 0x64, 0x8b, 0xeb, 0x59,
> + 0x38, 0x3f, 0xe7, 0x83, 0x2e, 0xe5, 0x64, 0x4d,
> + 0x5c, 0x1f, 0xe1, 0x3b, 0xd9, 0x84, 0xdb, 0xc9,
> + 0xec, 0xd8, 0xc1, 0x7c, 0x1f, 0x1b, 0x68, 0x35,
> + 0xc6, 0x34, 0x10, 0xef, 0x19, 0xc9, 0x0a, 0xd6,
> + 0x43, 0x7f, 0xa6, 0xcb, 0x9d, 0xf4, 0xf0, 0x16,
> + 0xb1, 0xb1, 0x96, 0x64, 0xec, 0x8d, 0x22, 0x4c,
> + 0x4b, 0xe8, 0x1a, 0xba, 0x6f, 0xb7, 0xfc, 0xa5,
> + 0x69, 0x3e, 0xad, 0x78, 0x79, 0x19, 0xb5, 0x04,
> + 0x69, 0xe5, 0x3f, 0xff, 0x60, 0x8c, 0xda, 0x0b,
> + 0x7b, 0xf7, 0xe7, 0xe6, 0x29, 0x3a, 0x85, 0xba,
> + 0xb5, 0xb0, 0x35, 0xbd, 0x38, 0xce, 0x34, 0x5e,
> + 0xf2, 0xdc, 0xd1, 0x8f, 0xc3, 0x03, 0x24, 0xa2,
> + 0x03, 0xf7, 0x4e, 0x49, 0x5b, 0xcf, 0x6d, 0xb0,
> + 0xeb, 0xe3, 0x30, 0x28, 0xd5, 0x5b, 0x82, 0x5f,
> + 0xe4, 0x7c, 0x1e, 0xec, 0xd2, 0x39, 0xf9, 0x6f,
> + 0x2e, 0xb3, 0xcd, 0x01, 0xb1, 0x67, 0xaa, 0xea,
> + 0xaa, 0xb3, 0x63, 0xaf, 0xd9, 0xb2, 0x1f, 0xba,
> + 0x05, 0x20, 0xeb, 0x19, 0x32, 0xf0, 0x6c, 0x3f,
> + 0x40, 0xcc, 0x93, 0xb3, 0xd8, 0x25, 0xa6, 0xe4,
> + 0xce, 0xd7, 0x7e, 0x48, 0x99, 0x65, 0x7f, 0x86,
> + 0xc5, 0xd4, 0x79, 0x6b, 0xab, 0x43, 0xb8, 0x6b,
> + 0xf1, 0x2f, 0xea, 0x4c, 0x5e, 0xf0, 0x3b, 0xb4,
> + 0xb8, 0xb0, 0x94, 0x0c, 0x6b, 0xe7, 0x22, 0x93,
> + 0xaa, 0x01, 0xcb, 0xf1, 0x11, 0x60, 0xf6, 0x69,
> + 0xcf, 0x14, 0xde, 0xfb, 0x90, 0x05, 0x27, 0x0c,
> + 0x1a, 0x9e, 0xf0, 0xb4, 0xc6, 0xa1, 0xe8, 0xdd,
> + 0xd0, 0x4c, 0x25, 0x4f, 0x9c, 0xb7, 0xb1, 0xb0,
> + 0x21, 0xdb, 0x87, 0x09, 0x03, 0xf2, 0xb3
> +};
> +static const u8 key70[] __initconst = {
> + 0x3b, 0x5b, 0x59, 0x36, 0x44, 0xd1, 0xba, 0x71,
> + 0x55, 0x87, 0x4d, 0x62, 0x3d, 0xc2, 0xfc, 0xaa,
> + 0x3f, 0x4e, 0x1a, 0xe4, 0xca, 0x09, 0xfc, 0x6a,
> + 0xb2, 0xd6, 0x5d, 0x79, 0xf9, 0x1a, 0x91, 0xa7
> +};
> +enum { nonce70 = 0x3fd6786dd147a85ULL };
> +
> +static const u8 input71[] __initconst = {
> + 0x18, 0x78, 0xd6, 0x79, 0xe4, 0x9a, 0x6c, 0x73,
> + 0x17, 0xd4, 0x05, 0x0f, 0x1e, 0x9f, 0xd9, 0x2b,
> + 0x86, 0x48, 0x7d, 0xf4, 0xd9, 0x1c, 0x76, 0xfc,
> + 0x8e, 0x22, 0x34, 0xe1, 0x48, 0x4a, 0x8d, 0x79,
> + 0xb7, 0xbb, 0x88, 0xab, 0x90, 0xde, 0xc5, 0xb4,
> + 0xb4, 0xe7, 0x85, 0x49, 0xda, 0x57, 0xeb, 0xc9,
> + 0xcd, 0x21, 0xfc, 0x45, 0x6e, 0x32, 0x67, 0xf2,
> + 0x4f, 0xa6, 0x54, 0xe5, 0x20, 0xed, 0xcf, 0xc6,
> + 0x62, 0x25, 0x8e, 0x00, 0xf8, 0x6b, 0xa2, 0x80,
> + 0xac, 0x88, 0xa6, 0x59, 0x27, 0x83, 0x95, 0x11,
> + 0x3f, 0x70, 0x5e, 0x3f, 0x11, 0xfb, 0x26, 0xbf,
> + 0xe1, 0x48, 0x75, 0xf9, 0x86, 0xbf, 0xa6, 0x5d,
> + 0x15, 0x61, 0x66, 0xbf, 0x78, 0x8f, 0x6b, 0x9b,
> + 0xda, 0x98, 0xb7, 0x19, 0xe2, 0xf2, 0xa3, 0x9c,
> + 0x7c, 0x6a, 0x9a, 0xd8, 0x3d, 0x4c, 0x2c, 0xe1,
> + 0x09, 0xb4, 0x28, 0x82, 0x4e, 0xab, 0x0c, 0x75,
> + 0x63, 0xeb, 0xbc, 0xd0, 0x71, 0xa2, 0x73, 0x85,
> + 0xed, 0x53, 0x7a, 0x3f, 0x68, 0x9f, 0xd0, 0xa9,
> + 0x00, 0x5a, 0x9e, 0x80, 0x55, 0x00, 0xe6, 0xae,
> + 0x0c, 0x03, 0x40, 0xed, 0xfc, 0x68, 0x4a, 0xb7,
> + 0x1e, 0x09, 0x65, 0x30, 0x5a, 0x3d, 0x97, 0x4d,
> + 0x5e, 0x51, 0x8e, 0xda, 0xc3, 0x55, 0x8c, 0xfb,
> + 0xcf, 0x83, 0x05, 0x35, 0x0d, 0x08, 0x1b, 0xf3,
> + 0x3a, 0x57, 0x96, 0xac, 0x58, 0x8b, 0xfa, 0x00,
> + 0x49, 0x15, 0x78, 0xd2, 0x4b, 0xed, 0xb8, 0x59,
> + 0x78, 0x9b, 0x7f, 0xaa, 0xfc, 0xe7, 0x46, 0xdc,
> + 0x7b, 0x34, 0xd0, 0x34, 0xe5, 0x10, 0xff, 0x4d,
> + 0x5a, 0x4d, 0x60, 0xa7, 0x16, 0x54, 0xc4, 0xfd,
> + 0xca, 0x5d, 0x68, 0xc7, 0x4a, 0x01, 0x8d, 0x7f,
> + 0x74, 0x5d, 0xff, 0xb8, 0x37, 0x15, 0x62, 0xfa,
> + 0x44, 0x45, 0xcf, 0x77, 0x3b, 0x1d, 0xb2, 0xd2,
> + 0x0d, 0x42, 0x00, 0x39, 0x68, 0x1f, 0xcc, 0x89,
> + 0x73, 0x5d, 0xa9, 0x2e, 0xfd, 0x58, 0x62, 0xca,
> + 0x35, 0x8e, 0x70, 0x70, 0xaa, 0x6e, 0x14, 0xe9,
> + 0xa4, 0xe2, 0x10, 0x66, 0x71, 0xdc, 0x4c, 0xfc,
> + 0xa9, 0xdc, 0x8f, 0x57, 0x4d, 0xc5, 0xac, 0xd7,
> + 0xa9, 0xf3, 0xf3, 0xa1, 0xff, 0x62, 0xa0, 0x8f,
> + 0xe4, 0x96, 0x3e, 0xcb, 0x9f, 0x76, 0x42, 0x39,
> + 0x1f, 0x24, 0xfd, 0xfd, 0x79, 0xe8, 0x27, 0xdf,
> + 0xa8, 0xf6, 0x33, 0x8b, 0x31, 0x59, 0x69, 0xcf,
> + 0x6a, 0xef, 0x89, 0x4d, 0xa7, 0xf6, 0x7e, 0x97,
> + 0x14, 0xbd, 0xda, 0xdd, 0xb4, 0x84, 0x04, 0x24,
> + 0xe0, 0x17, 0xe1, 0x0f, 0x1f, 0x8a, 0x6a, 0x71,
> + 0x74, 0x41, 0xdc, 0x59, 0x5c, 0x8f, 0x01, 0x25,
> + 0x92, 0xf0, 0x2e, 0x15, 0x62, 0x71, 0x9a, 0x9f,
> + 0x87, 0xdf, 0x62, 0x49, 0x7f, 0x86, 0x62, 0xfc,
> + 0x20, 0x84, 0xd7, 0xe3, 0x3a, 0xd9, 0x37, 0x85,
> + 0xb7, 0x84, 0x5a, 0xf9, 0xed, 0x21, 0x32, 0x94,
> + 0x3e, 0x04, 0xe7, 0x8c, 0x46, 0x76, 0x21, 0x67,
> + 0xf6, 0x95, 0x64, 0x92, 0xb7, 0x15, 0xf6, 0xe3,
> + 0x41, 0x27, 0x9d, 0xd7, 0xe3, 0x79, 0x75, 0x92,
> + 0xd0, 0xc1, 0xf3, 0x40, 0x92, 0x08, 0xde, 0x90,
> + 0x22, 0x82, 0xb2, 0x69, 0xae, 0x1a, 0x35, 0x11,
> + 0x89, 0xc8, 0x06, 0x82, 0x95, 0x23, 0x44, 0x08,
> + 0x22, 0xf2, 0x71, 0x73, 0x1b, 0x88, 0x11, 0xcf,
> + 0x1c, 0x7e, 0x8a, 0x2e, 0xdc, 0x79, 0x57, 0xce,
> + 0x1f, 0xe7, 0x6c, 0x07, 0xd8, 0x06, 0xbe, 0xec,
> + 0xa3, 0xcf, 0xf9, 0x68, 0xa5, 0xb8, 0xf0, 0xe3,
> + 0x3f, 0x01, 0x92, 0xda, 0xf1, 0xa0, 0x2d, 0x7b,
> + 0xab, 0x57, 0x58, 0x2a, 0xaf, 0xab, 0xbd, 0xf2,
> + 0xe5, 0xaf, 0x7e, 0x1f, 0x46, 0x24, 0x9e, 0x20,
> + 0x22, 0x0f, 0x84, 0x4c, 0xb7, 0xd8, 0x03, 0xe8,
> + 0x09, 0x73, 0x6c, 0xc6, 0x9b, 0x90, 0xe0, 0xdb,
> + 0xf2, 0x71, 0xba, 0xad, 0xb3, 0xec, 0xda, 0x7a
> +};
> +static const u8 output71[] __initconst = {
> + 0x28, 0xc5, 0x9b, 0x92, 0xf9, 0x21, 0x4f, 0xbb,
> + 0xef, 0x3b, 0xf0, 0xf5, 0x3a, 0x6d, 0x7f, 0xd6,
> + 0x6a, 0x8d, 0xa1, 0x01, 0x5c, 0x62, 0x20, 0x8b,
> + 0x5b, 0x39, 0xd5, 0xd3, 0xc2, 0xf6, 0x9d, 0x5e,
> + 0xcc, 0xe1, 0xa2, 0x61, 0x16, 0xe2, 0xce, 0xe9,
> + 0x86, 0xd0, 0xfc, 0xce, 0x9a, 0x28, 0x27, 0xc4,
> + 0x0c, 0xb9, 0xaa, 0x8d, 0x48, 0xdb, 0xbf, 0x82,
> + 0x7d, 0xd0, 0x35, 0xc4, 0x06, 0x34, 0xb4, 0x19,
> + 0x51, 0x73, 0xf4, 0x7a, 0xf4, 0xfd, 0xe9, 0x1d,
> + 0xdc, 0x0f, 0x7e, 0xf7, 0x96, 0x03, 0xe3, 0xb1,
> + 0x2e, 0x22, 0x59, 0xb7, 0x6d, 0x1c, 0x97, 0x8c,
> + 0xd7, 0x31, 0x08, 0x26, 0x4c, 0x6d, 0xc6, 0x14,
> + 0xa5, 0xeb, 0x45, 0x6a, 0x88, 0xa3, 0xa2, 0x36,
> + 0xc4, 0x35, 0xb1, 0x5a, 0xa0, 0xad, 0xf7, 0x06,
> + 0x9b, 0x5d, 0xc1, 0x15, 0xc1, 0xce, 0x0a, 0xb0,
> + 0x57, 0x2e, 0x3f, 0x6f, 0x0d, 0x10, 0xd9, 0x11,
> + 0x2c, 0x9c, 0xad, 0x2d, 0xa5, 0x81, 0xfb, 0x4e,
> + 0x8f, 0xd5, 0x32, 0x4e, 0xaf, 0x5c, 0xc1, 0x86,
> + 0xde, 0x56, 0x5a, 0x33, 0x29, 0xf7, 0x67, 0xc6,
> + 0x37, 0x6f, 0xb2, 0x37, 0x4e, 0xd4, 0x69, 0x79,
> + 0xaf, 0xd5, 0x17, 0x79, 0xe0, 0xba, 0x62, 0xa3,
> + 0x68, 0xa4, 0x87, 0x93, 0x8d, 0x7e, 0x8f, 0xa3,
> + 0x9c, 0xef, 0xda, 0xe3, 0xa5, 0x1f, 0xcd, 0x30,
> + 0xa6, 0x55, 0xac, 0x4c, 0x69, 0x74, 0x02, 0xc7,
> + 0x5d, 0x95, 0x81, 0x4a, 0x68, 0x11, 0xd3, 0xa9,
> + 0x98, 0xb1, 0x0b, 0x0d, 0xae, 0x40, 0x86, 0x65,
> + 0xbf, 0xcc, 0x2d, 0xef, 0x57, 0xca, 0x1f, 0xe4,
> + 0x34, 0x4e, 0xa6, 0x5e, 0x82, 0x6e, 0x61, 0xad,
> + 0x0b, 0x3c, 0xf8, 0xeb, 0x01, 0x43, 0x7f, 0x87,
> + 0xa2, 0xa7, 0x6a, 0xe9, 0x62, 0x23, 0x24, 0x61,
> + 0xf1, 0xf7, 0x36, 0xdb, 0x10, 0xe5, 0x57, 0x72,
> + 0x3a, 0xc2, 0xae, 0xcc, 0x75, 0xc7, 0x80, 0x05,
> + 0x0a, 0x5c, 0x4c, 0x95, 0xda, 0x02, 0x01, 0x14,
> + 0x06, 0x6b, 0x5c, 0x65, 0xc2, 0xb8, 0x4a, 0xd6,
> + 0xd3, 0xb4, 0xd8, 0x12, 0x52, 0xb5, 0x60, 0xd3,
> + 0x8e, 0x5f, 0x5c, 0x76, 0x33, 0x7a, 0x05, 0xe5,
> + 0xcb, 0xef, 0x4f, 0x89, 0xf1, 0xba, 0x32, 0x6f,
> + 0x33, 0xcd, 0x15, 0x8d, 0xa3, 0x0c, 0x3f, 0x63,
> + 0x11, 0xe7, 0x0e, 0xe0, 0x00, 0x01, 0xe9, 0xe8,
> + 0x8e, 0x36, 0x34, 0x8d, 0x96, 0xb5, 0x03, 0xcf,
> + 0x55, 0x62, 0x49, 0x7a, 0x34, 0x44, 0xa5, 0xee,
> + 0x8c, 0x46, 0x06, 0x22, 0xab, 0x1d, 0x53, 0x9c,
> + 0xa1, 0xf9, 0x67, 0x18, 0x57, 0x89, 0xf9, 0xc2,
> + 0xd1, 0x7e, 0xbe, 0x36, 0x40, 0xcb, 0xe9, 0x04,
> + 0xde, 0xb1, 0x3b, 0x29, 0x52, 0xc5, 0x9a, 0xb5,
> + 0xa2, 0x7c, 0x7b, 0xfe, 0xe5, 0x92, 0x73, 0xea,
> + 0xea, 0x7b, 0xba, 0x0a, 0x8c, 0x88, 0x15, 0xe6,
> + 0x53, 0xbf, 0x1c, 0x33, 0xf4, 0x9b, 0x9a, 0x5e,
> + 0x8d, 0xae, 0x60, 0xdc, 0xcb, 0x5d, 0xfa, 0xbe,
> + 0x06, 0xc3, 0x3f, 0x06, 0xe7, 0x00, 0x40, 0x7b,
> + 0xaa, 0x94, 0xfa, 0x6d, 0x1f, 0xe4, 0xc5, 0xa9,
> + 0x1b, 0x5f, 0x36, 0xea, 0x5a, 0xdd, 0xa5, 0x48,
> + 0x6a, 0x55, 0xd2, 0x47, 0x28, 0xbf, 0x96, 0xf1,
> + 0x9f, 0xb6, 0x11, 0x4b, 0xd3, 0x44, 0x7d, 0x48,
> + 0x41, 0x61, 0xdb, 0x12, 0xd4, 0xc2, 0x59, 0x82,
> + 0x4c, 0x47, 0x5c, 0x04, 0xf6, 0x7b, 0xd3, 0x92,
> + 0x2e, 0xe8, 0x40, 0xef, 0x15, 0x32, 0x97, 0xdc,
> + 0x35, 0x4c, 0x6e, 0xa4, 0x97, 0xe9, 0x24, 0xde,
> + 0x63, 0x8b, 0xb1, 0x6b, 0x48, 0xbb, 0x46, 0x1f,
> + 0x84, 0xd6, 0x17, 0xb0, 0x5a, 0x4a, 0x4e, 0xd5,
> + 0x31, 0xd7, 0xcf, 0xa0, 0x39, 0xc6, 0x2e, 0xfc,
> + 0xa6, 0xa3, 0xd3, 0x0f, 0xa4, 0x28, 0xac, 0xb2,
> + 0xf4, 0x48, 0x8d, 0x50, 0xa5, 0x1c, 0x44, 0x5d,
> + 0x6e, 0x38, 0xb7, 0x2b, 0x8a, 0x45, 0xa7, 0x3d
> +};
> +static const u8 key71[] __initconst = {
> + 0x8b, 0x68, 0xc4, 0xb7, 0x0d, 0x81, 0xef, 0x52,
> + 0x1e, 0x05, 0x96, 0x72, 0x62, 0x89, 0x27, 0x83,
> + 0xd0, 0xc7, 0x33, 0x6d, 0xf2, 0xcc, 0x69, 0xf9,
> + 0x23, 0xae, 0x99, 0xb1, 0xd1, 0x05, 0x4e, 0x54
> +};
> +enum { nonce71 = 0x983f03656d64b5f6ULL };
> +
> +static const u8 input72[] __initconst = {
> + 0x6b, 0x09, 0xc9, 0x57, 0x3d, 0x79, 0x04, 0x8c,
> + 0x65, 0xad, 0x4a, 0x0f, 0xa1, 0x31, 0x3a, 0xdd,
> + 0x14, 0x8e, 0xe8, 0xfe, 0xbf, 0x42, 0x87, 0x98,
> + 0x2e, 0x8d, 0x83, 0xa3, 0xf8, 0x55, 0x3d, 0x84,
> + 0x1e, 0x0e, 0x05, 0x4a, 0x38, 0x9e, 0xe7, 0xfe,
> + 0xd0, 0x4d, 0x79, 0x74, 0x3a, 0x0b, 0x9b, 0xe1,
> + 0xfd, 0x51, 0x84, 0x4e, 0xb2, 0x25, 0xe4, 0x64,
> + 0x4c, 0xda, 0xcf, 0x46, 0xec, 0xba, 0x12, 0xeb,
> + 0x5a, 0x33, 0x09, 0x6e, 0x78, 0x77, 0x8f, 0x30,
> + 0xb1, 0x7d, 0x3f, 0x60, 0x8c, 0xf2, 0x1d, 0x8e,
> + 0xb4, 0x70, 0xa2, 0x90, 0x7c, 0x79, 0x1a, 0x2c,
> + 0xf6, 0x28, 0x79, 0x7c, 0x53, 0xc5, 0xfa, 0xcc,
> + 0x65, 0x9b, 0xe1, 0x51, 0xd1, 0x7f, 0x1d, 0xc4,
> + 0xdb, 0xd4, 0xd9, 0x04, 0x61, 0x7d, 0xbe, 0x12,
> + 0xfc, 0xcd, 0xaf, 0xe4, 0x0f, 0x9c, 0x20, 0xb5,
> + 0x22, 0x40, 0x18, 0xda, 0xe4, 0xda, 0x8c, 0x2d,
> + 0x84, 0xe3, 0x5f, 0x53, 0x17, 0xed, 0x78, 0xdc,
> + 0x2f, 0xe8, 0x31, 0xc7, 0xe6, 0x39, 0x71, 0x40,
> + 0xb4, 0x0f, 0xc9, 0xa9, 0x7e, 0x78, 0x87, 0xc1,
> + 0x05, 0x78, 0xbb, 0x01, 0xf2, 0x8f, 0x33, 0xb0,
> + 0x6e, 0x84, 0xcd, 0x36, 0x33, 0x5c, 0x5b, 0x8e,
> + 0xf1, 0xac, 0x30, 0xfe, 0x33, 0xec, 0x08, 0xf3,
> + 0x7e, 0xf2, 0xf0, 0x4c, 0xf2, 0xad, 0xd8, 0xc1,
> + 0xd4, 0x4e, 0x87, 0x06, 0xd4, 0x75, 0xe7, 0xe3,
> + 0x09, 0xd3, 0x4d, 0xe3, 0x21, 0x32, 0xba, 0xb4,
> + 0x68, 0x68, 0xcb, 0x4c, 0xa3, 0x1e, 0xb3, 0x87,
> + 0x7b, 0xd3, 0x0c, 0x63, 0x37, 0x71, 0x79, 0xfb,
> + 0x58, 0x36, 0x57, 0x0f, 0x34, 0x1d, 0xc1, 0x42,
> + 0x02, 0x17, 0xe7, 0xed, 0xe8, 0xe7, 0x76, 0xcb,
> + 0x42, 0xc4, 0x4b, 0xe2, 0xb2, 0x5e, 0x42, 0xd5,
> + 0xec, 0x9d, 0xc1, 0x32, 0x71, 0xe4, 0xeb, 0x10,
> + 0x68, 0x1a, 0x6e, 0x99, 0x8e, 0x73, 0x12, 0x1f,
> + 0x97, 0x0c, 0x9e, 0xcd, 0x02, 0x3e, 0x4c, 0xa0,
> + 0xf2, 0x8d, 0xe5, 0x44, 0xca, 0x6d, 0xfe, 0x07,
> + 0xe3, 0xe8, 0x9b, 0x76, 0xc1, 0x6d, 0xb7, 0x6e,
> + 0x0d, 0x14, 0x00, 0x6f, 0x8a, 0xfd, 0x43, 0xc6,
> + 0x43, 0xa5, 0x9c, 0x02, 0x47, 0x10, 0xd4, 0xb4,
> + 0x9b, 0x55, 0x67, 0xc8, 0x7f, 0xc1, 0x8a, 0x1f,
> + 0x1e, 0xd1, 0xbc, 0x99, 0x5d, 0x50, 0x4f, 0x89,
> + 0xf1, 0xe6, 0x5d, 0x91, 0x40, 0xdc, 0x20, 0x67,
> + 0x56, 0xc2, 0xef, 0xbd, 0x2c, 0xa2, 0x99, 0x38,
> + 0xe0, 0x45, 0xec, 0x44, 0x05, 0x52, 0x65, 0x11,
> + 0xfc, 0x3b, 0x19, 0xcb, 0x71, 0xc2, 0x8e, 0x0e,
> + 0x03, 0x2a, 0x03, 0x3b, 0x63, 0x06, 0x31, 0x9a,
> + 0xac, 0x53, 0x04, 0x14, 0xd4, 0x80, 0x9d, 0x6b,
> + 0x42, 0x7e, 0x7e, 0x4e, 0xdc, 0xc7, 0x01, 0x49,
> + 0x9f, 0xf5, 0x19, 0x86, 0x13, 0x28, 0x2b, 0xa6,
> + 0xa6, 0xbe, 0xa1, 0x7e, 0x71, 0x05, 0x00, 0xff,
> + 0x59, 0x2d, 0xb6, 0x63, 0xf0, 0x1e, 0x2e, 0x69,
> + 0x9b, 0x85, 0xf1, 0x1e, 0x8a, 0x64, 0x39, 0xab,
> + 0x00, 0x12, 0xe4, 0x33, 0x4b, 0xb5, 0xd8, 0xb3,
> + 0x6b, 0x5b, 0x8b, 0x5c, 0xd7, 0x6f, 0x23, 0xcf,
> + 0x3f, 0x2e, 0x5e, 0x47, 0xb9, 0xb8, 0x1f, 0xf0,
> + 0x1d, 0xda, 0xe7, 0x4f, 0x6e, 0xab, 0xc3, 0x36,
> + 0xb4, 0x74, 0x6b, 0xeb, 0xc7, 0x5d, 0x91, 0xe5,
> + 0xda, 0xf2, 0xc2, 0x11, 0x17, 0x48, 0xf8, 0x9c,
> + 0xc9, 0x8b, 0xc1, 0xa2, 0xf4, 0xcd, 0x16, 0xf8,
> + 0x27, 0xd9, 0x6c, 0x6f, 0xb5, 0x8f, 0x77, 0xca,
> + 0x1b, 0xd8, 0xef, 0x84, 0x68, 0x71, 0x53, 0xc1,
> + 0x43, 0x0f, 0x9f, 0x98, 0xae, 0x7e, 0x31, 0xd2,
> + 0x98, 0xfb, 0x20, 0xa2, 0xad, 0x00, 0x10, 0x83,
> + 0x00, 0x8b, 0xeb, 0x56, 0xd2, 0xc4, 0xcc, 0x7f,
> + 0x2f, 0x4e, 0xfa, 0x88, 0x13, 0xa4, 0x2c, 0xde,
> + 0x6b, 0x77, 0x86, 0x10, 0x6a, 0xab, 0x43, 0x0a,
> + 0x02
> +};
> +static const u8 output72[] __initconst = {
> + 0x42, 0x89, 0xa4, 0x80, 0xd2, 0xcb, 0x5f, 0x7f,
> + 0x2a, 0x1a, 0x23, 0x00, 0xa5, 0x6a, 0x95, 0xa3,
> + 0x9a, 0x41, 0xa1, 0xd0, 0x2d, 0x1e, 0xd6, 0x13,
> + 0x34, 0x40, 0x4e, 0x7f, 0x1a, 0xbe, 0xa0, 0x3d,
> + 0x33, 0x9c, 0x56, 0x2e, 0x89, 0x25, 0x45, 0xf9,
> + 0xf0, 0xba, 0x9c, 0x6d, 0xd1, 0xd1, 0xde, 0x51,
> + 0x47, 0x63, 0xc9, 0xbd, 0xfa, 0xa2, 0x9e, 0xad,
> + 0x6a, 0x7b, 0x21, 0x1a, 0x6c, 0x3e, 0xff, 0x46,
> + 0xbe, 0xf3, 0x35, 0x7a, 0x6e, 0xb3, 0xb9, 0xf7,
> + 0xda, 0x5e, 0xf0, 0x14, 0xb5, 0x70, 0xa4, 0x2b,
> + 0xdb, 0xbb, 0xc7, 0x31, 0x4b, 0x69, 0x5a, 0x83,
> + 0x70, 0xd9, 0x58, 0xd4, 0x33, 0x84, 0x23, 0xf0,
> + 0xae, 0xbb, 0x6d, 0x26, 0x7c, 0xc8, 0x30, 0xf7,
> + 0x24, 0xad, 0xbd, 0xe4, 0x2c, 0x38, 0x38, 0xac,
> + 0xe1, 0x4a, 0x9b, 0xac, 0x33, 0x0e, 0x4a, 0xf4,
> + 0x93, 0xed, 0x07, 0x82, 0x81, 0x4f, 0x8f, 0xb1,
> + 0xdd, 0x73, 0xd5, 0x50, 0x6d, 0x44, 0x1e, 0xbe,
> + 0xa7, 0xcd, 0x17, 0x57, 0xd5, 0x3b, 0x62, 0x36,
> + 0xcf, 0x7d, 0xc8, 0xd8, 0xd1, 0x78, 0xd7, 0x85,
> + 0x46, 0x76, 0x5d, 0xcc, 0xfe, 0xe8, 0x94, 0xc5,
> + 0xad, 0xbc, 0x5e, 0xbc, 0x8d, 0x1d, 0xdf, 0x03,
> + 0xc9, 0x6b, 0x1b, 0x81, 0xd1, 0xb6, 0x5a, 0x24,
> + 0xe3, 0xdc, 0x3f, 0x20, 0xc9, 0x07, 0x73, 0x4c,
> + 0x43, 0x13, 0x87, 0x58, 0x34, 0x0d, 0x14, 0x63,
> + 0x0f, 0x6f, 0xad, 0x8d, 0xac, 0x7c, 0x67, 0x68,
> + 0xa3, 0x9d, 0x7f, 0x00, 0xdf, 0x28, 0xee, 0x67,
> + 0xf4, 0x5c, 0x26, 0xcb, 0xef, 0x56, 0x71, 0xc8,
> + 0xc6, 0x67, 0x5f, 0x38, 0xbb, 0xa0, 0xb1, 0x5c,
> + 0x1f, 0xb3, 0x08, 0xd9, 0x38, 0xcf, 0x74, 0x54,
> + 0xc6, 0xa4, 0xc4, 0xc0, 0x9f, 0xb3, 0xd0, 0xda,
> + 0x62, 0x67, 0x8b, 0x81, 0x33, 0xf0, 0xa9, 0x73,
> + 0xa4, 0xd1, 0x46, 0x88, 0x8d, 0x85, 0x12, 0x40,
> + 0xba, 0x1a, 0xcd, 0x82, 0xd8, 0x8d, 0xc4, 0x52,
> + 0xe7, 0x01, 0x94, 0x2e, 0x0e, 0xd0, 0xaf, 0xe7,
> + 0x2d, 0x3f, 0x3c, 0xaa, 0xf4, 0xf5, 0xa7, 0x01,
> + 0x4c, 0x14, 0xe2, 0xc2, 0x96, 0x76, 0xbe, 0x05,
> + 0xaa, 0x19, 0xb1, 0xbd, 0x95, 0xbb, 0x5a, 0xf9,
> + 0xa5, 0xa7, 0xe6, 0x16, 0x38, 0x34, 0xf7, 0x9d,
> + 0x19, 0x66, 0x16, 0x8e, 0x7f, 0x2b, 0x5a, 0xfb,
> + 0xb5, 0x29, 0x79, 0xbf, 0x52, 0xae, 0x30, 0x95,
> + 0x3f, 0x31, 0x33, 0x28, 0xde, 0xc5, 0x0d, 0x55,
> + 0x89, 0xec, 0x21, 0x11, 0x0f, 0x8b, 0xfe, 0x63,
> + 0x3a, 0xf1, 0x95, 0x5c, 0xcd, 0x50, 0xe4, 0x5d,
> + 0x8f, 0xa7, 0xc8, 0xca, 0x93, 0xa0, 0x67, 0x82,
> + 0x63, 0x5c, 0xd0, 0xed, 0xe7, 0x08, 0xc5, 0x60,
> + 0xf8, 0xb4, 0x47, 0xf0, 0x1a, 0x65, 0x4e, 0xa3,
> + 0x51, 0x68, 0xc7, 0x14, 0xa1, 0xd9, 0x39, 0x72,
> + 0xa8, 0x6f, 0x7c, 0x7e, 0xf6, 0x03, 0x0b, 0x25,
> + 0x9b, 0xf2, 0xca, 0x49, 0xae, 0x5b, 0xf8, 0x0f,
> + 0x71, 0x51, 0x01, 0xa6, 0x23, 0xa9, 0xdf, 0xd0,
> + 0x7a, 0x39, 0x19, 0xf5, 0xc5, 0x26, 0x44, 0x7b,
> + 0x0a, 0x4a, 0x41, 0xbf, 0xf2, 0x8e, 0x83, 0x50,
> + 0x91, 0x96, 0x72, 0x02, 0xf6, 0x80, 0xbf, 0x95,
> + 0x41, 0xac, 0xda, 0xb0, 0xba, 0xe3, 0x76, 0xb1,
> + 0x9d, 0xff, 0x1f, 0x33, 0x02, 0x85, 0xfc, 0x2a,
> + 0x29, 0xe6, 0xe3, 0x9d, 0xd0, 0xef, 0xc2, 0xd6,
> + 0x9c, 0x4a, 0x62, 0xac, 0xcb, 0xea, 0x8b, 0xc3,
> + 0x08, 0x6e, 0x49, 0x09, 0x26, 0x19, 0xc1, 0x30,
> + 0xcc, 0x27, 0xaa, 0xc6, 0x45, 0x88, 0xbd, 0xae,
> + 0xd6, 0x79, 0xff, 0x4e, 0xfc, 0x66, 0x4d, 0x02,
> + 0xa5, 0xee, 0x8e, 0xa5, 0xb6, 0x15, 0x72, 0x24,
> + 0xb1, 0xbf, 0xbf, 0x64, 0xcf, 0xcc, 0x93, 0xe9,
> + 0xb6, 0xfd, 0xb4, 0xb6, 0x21, 0xb5, 0x48, 0x08,
> + 0x0f, 0x11, 0x65, 0xe1, 0x47, 0xee, 0x93, 0x29,
> + 0xad
> +};
> +static const u8 key72[] __initconst = {
> + 0xb9, 0xa2, 0xfc, 0x59, 0x06, 0x3f, 0x77, 0xa5,
> + 0x66, 0xd0, 0x2b, 0x22, 0x74, 0x22, 0x4c, 0x1e,
> + 0x6a, 0x39, 0xdf, 0xe1, 0x0d, 0x4c, 0x64, 0x99,
> + 0x54, 0x8a, 0xba, 0x1d, 0x2c, 0x21, 0x5f, 0xc3
> +};
> +enum { nonce72 = 0x3d069308fa3db04bULL };
> +
> +static const u8 input73[] __initconst = {
> + 0xe4, 0xdd, 0x36, 0xd4, 0xf5, 0x70, 0x51, 0x73,
> + 0x97, 0x1d, 0x45, 0x05, 0x92, 0xe7, 0xeb, 0xb7,
> + 0x09, 0x82, 0x6e, 0x25, 0x6c, 0x50, 0xf5, 0x40,
> + 0x19, 0xba, 0xbc, 0xf4, 0x39, 0x14, 0xc5, 0x15,
> + 0x83, 0x40, 0xbd, 0x26, 0xe0, 0xff, 0x3b, 0x22,
> + 0x7c, 0x7c, 0xd7, 0x0b, 0xe9, 0x25, 0x0c, 0x3d,
> + 0x92, 0x38, 0xbe, 0xe4, 0x22, 0x75, 0x65, 0xf1,
> + 0x03, 0x85, 0x34, 0x09, 0xb8, 0x77, 0xfb, 0x48,
> + 0xb1, 0x2e, 0x21, 0x67, 0x9b, 0x9d, 0xad, 0x18,
> + 0x82, 0x0d, 0x6b, 0xc3, 0xcf, 0x00, 0x61, 0x6e,
> + 0xda, 0xdc, 0xa7, 0x0b, 0x5c, 0x02, 0x1d, 0xa6,
> + 0x4e, 0x0d, 0x7f, 0x37, 0x01, 0x5a, 0x37, 0xf3,
> + 0x2b, 0xbf, 0xba, 0xe2, 0x1c, 0xb3, 0xa3, 0xbc,
> + 0x1c, 0x93, 0x1a, 0xb1, 0x71, 0xaf, 0xe2, 0xdd,
> + 0x17, 0xee, 0x53, 0xfa, 0xfb, 0x02, 0x40, 0x3e,
> + 0x03, 0xca, 0xe7, 0xc3, 0x51, 0x81, 0xcc, 0x8c,
> + 0xca, 0xcf, 0x4e, 0xc5, 0x78, 0x99, 0xfd, 0xbf,
> + 0xea, 0xab, 0x38, 0x81, 0xfc, 0xd1, 0x9e, 0x41,
> + 0x0b, 0x84, 0x25, 0xf1, 0x6b, 0x3c, 0xf5, 0x40,
> + 0x0d, 0xc4, 0x3e, 0xb3, 0x6a, 0xec, 0x6e, 0x75,
> + 0xdc, 0x9b, 0xdf, 0x08, 0x21, 0x16, 0xfb, 0x7a,
> + 0x8e, 0x19, 0x13, 0x02, 0xa7, 0xfc, 0x58, 0x21,
> + 0xc3, 0xb3, 0x59, 0x5a, 0x9c, 0xef, 0x38, 0xbd,
> + 0x87, 0x55, 0xd7, 0x0d, 0x1f, 0x84, 0xdc, 0x98,
> + 0x22, 0xca, 0x87, 0x96, 0x71, 0x6d, 0x68, 0x00,
> + 0xcb, 0x4f, 0x2f, 0xc4, 0x64, 0x0c, 0xc1, 0x53,
> + 0x0c, 0x90, 0xe7, 0x3c, 0x88, 0xca, 0xc5, 0x85,
> + 0xa3, 0x2a, 0x96, 0x7c, 0x82, 0x6d, 0x45, 0xf5,
> + 0xb7, 0x8d, 0x17, 0x69, 0xd6, 0xcd, 0x3c, 0xd3,
> + 0xe7, 0x1c, 0xce, 0x93, 0x50, 0xd4, 0x59, 0xa2,
> + 0xd8, 0x8b, 0x72, 0x60, 0x5b, 0x25, 0x14, 0xcd,
> + 0x5a, 0xe8, 0x8c, 0xdb, 0x23, 0x8d, 0x2b, 0x59,
> + 0x12, 0x13, 0x10, 0x47, 0xa4, 0xc8, 0x3c, 0xc1,
> + 0x81, 0x89, 0x6c, 0x98, 0xec, 0x8f, 0x7b, 0x32,
> + 0xf2, 0x87, 0xd9, 0xa2, 0x0d, 0xc2, 0x08, 0xf9,
> + 0xd5, 0xf3, 0x91, 0xe7, 0xb3, 0x87, 0xa7, 0x0b,
> + 0x64, 0x8f, 0xb9, 0x55, 0x1c, 0x81, 0x96, 0x6c,
> + 0xa1, 0xc9, 0x6e, 0x3b, 0xcd, 0x17, 0x1b, 0xfc,
> + 0xa6, 0x05, 0xba, 0x4a, 0x7d, 0x03, 0x3c, 0x59,
> + 0xc8, 0xee, 0x50, 0xb2, 0x5b, 0xe1, 0x4d, 0x6a,
> + 0x1f, 0x09, 0xdc, 0xa2, 0x51, 0xd1, 0x93, 0x3a,
> + 0x5f, 0x72, 0x1d, 0x26, 0x14, 0x62, 0xa2, 0x41,
> + 0x3d, 0x08, 0x70, 0x7b, 0x27, 0x3d, 0xbc, 0xdf,
> + 0x15, 0xfa, 0xb9, 0x5f, 0xb5, 0x38, 0x84, 0x0b,
> + 0x58, 0x3d, 0xee, 0x3f, 0x32, 0x65, 0x6d, 0xd7,
> + 0xce, 0x97, 0x3c, 0x8d, 0xfb, 0x63, 0xb9, 0xb0,
> + 0xa8, 0x4a, 0x72, 0x99, 0x97, 0x58, 0xc8, 0xa7,
> + 0xf9, 0x4c, 0xae, 0xc1, 0x63, 0xb9, 0x57, 0x18,
> + 0x8a, 0xfa, 0xab, 0xe9, 0xf3, 0x67, 0xe6, 0xfd,
> + 0xd2, 0x9d, 0x5c, 0xa9, 0x8e, 0x11, 0x0a, 0xf4,
> + 0x4b, 0xf1, 0xec, 0x1a, 0xaf, 0x50, 0x5d, 0x16,
> + 0x13, 0x69, 0x2e, 0xbd, 0x0d, 0xe6, 0xf0, 0xb2,
> + 0xed, 0xb4, 0x4c, 0x59, 0x77, 0x37, 0x00, 0x0b,
> + 0xc7, 0xa7, 0x9e, 0x37, 0xf3, 0x60, 0x70, 0xef,
> + 0xf3, 0xc1, 0x74, 0x52, 0x87, 0xc6, 0xa1, 0x81,
> + 0xbd, 0x0a, 0x2c, 0x5d, 0x2c, 0x0c, 0x6a, 0x81,
> + 0xa1, 0xfe, 0x26, 0x78, 0x6c, 0x03, 0x06, 0x07,
> + 0x34, 0xaa, 0xd1, 0x1b, 0x40, 0x03, 0x39, 0x56,
> + 0xcf, 0x2a, 0x92, 0xc1, 0x4e, 0xdf, 0x29, 0x24,
> + 0x83, 0x22, 0x7a, 0xea, 0x67, 0x1e, 0xe7, 0x54,
> + 0x64, 0xd3, 0xbd, 0x3a, 0x5d, 0xae, 0xca, 0xf0,
> + 0x9c, 0xd6, 0x5a, 0x9a, 0x62, 0xc8, 0xc7, 0x83,
> + 0xf9, 0x89, 0xde, 0x2d, 0x53, 0x64, 0x61, 0xf7,
> + 0xa3, 0xa7, 0x31, 0x38, 0xc6, 0x22, 0x9c, 0xb4,
> + 0x87, 0xe0
> +};
> +static const u8 output73[] __initconst = {
> + 0x34, 0xed, 0x05, 0xb0, 0x14, 0xbc, 0x8c, 0xcc,
> + 0x95, 0xbd, 0x99, 0x0f, 0xb1, 0x98, 0x17, 0x10,
> + 0xae, 0xe0, 0x08, 0x53, 0xa3, 0x69, 0xd2, 0xed,
> + 0x66, 0xdb, 0x2a, 0x34, 0x8d, 0x0c, 0x6e, 0xce,
> + 0x63, 0x69, 0xc9, 0xe4, 0x57, 0xc3, 0x0c, 0x8b,
> + 0xa6, 0x2c, 0xa7, 0xd2, 0x08, 0xff, 0x4f, 0xec,
> + 0x61, 0x8c, 0xee, 0x0d, 0xfa, 0x6b, 0xe0, 0xe8,
> + 0x71, 0xbc, 0x41, 0x46, 0xd7, 0x33, 0x1d, 0xc0,
> + 0xfd, 0xad, 0xca, 0x8b, 0x34, 0x56, 0xa4, 0x86,
> + 0x71, 0x62, 0xae, 0x5e, 0x3d, 0x2b, 0x66, 0x3e,
> + 0xae, 0xd8, 0xc0, 0xe1, 0x21, 0x3b, 0xca, 0xd2,
> + 0x6b, 0xa2, 0xb8, 0xc7, 0x98, 0x4a, 0xf3, 0xcf,
> + 0xb8, 0x62, 0xd8, 0x33, 0xe6, 0x80, 0xdb, 0x2f,
> + 0x0a, 0xaf, 0x90, 0x3c, 0xe1, 0xec, 0xe9, 0x21,
> + 0x29, 0x42, 0x9e, 0xa5, 0x50, 0xe9, 0x93, 0xd3,
> + 0x53, 0x1f, 0xac, 0x2a, 0x24, 0x07, 0xb8, 0xed,
> + 0xed, 0x38, 0x2c, 0xc4, 0xa1, 0x2b, 0x31, 0x5d,
> + 0x9c, 0x24, 0x7b, 0xbf, 0xd9, 0xbb, 0x4e, 0x87,
> + 0x8f, 0x32, 0x30, 0xf1, 0x11, 0x29, 0x54, 0x94,
> + 0x00, 0x95, 0x1d, 0x1d, 0x24, 0xc0, 0xd4, 0x34,
> + 0x49, 0x1d, 0xd5, 0xe3, 0xa6, 0xde, 0x8b, 0xbf,
> + 0x5a, 0x9f, 0x58, 0x5a, 0x9b, 0x70, 0xe5, 0x9b,
> + 0xb3, 0xdb, 0xe8, 0xb8, 0xca, 0x1b, 0x43, 0xe3,
> + 0xc6, 0x6f, 0x0a, 0xd6, 0x32, 0x11, 0xd4, 0x04,
> + 0xef, 0xa3, 0xe4, 0x3f, 0x12, 0xd8, 0xc1, 0x73,
> + 0x51, 0x87, 0x03, 0xbd, 0xba, 0x60, 0x79, 0xee,
> + 0x08, 0xcc, 0xf7, 0xc0, 0xaa, 0x4c, 0x33, 0xc4,
> + 0xc7, 0x09, 0xf5, 0x91, 0xcb, 0x74, 0x57, 0x08,
> + 0x1b, 0x90, 0xa9, 0x1b, 0x60, 0x02, 0xd2, 0x3f,
> + 0x7a, 0xbb, 0xfd, 0x78, 0xf0, 0x15, 0xf9, 0x29,
> + 0x82, 0x8f, 0xc4, 0xb2, 0x88, 0x1f, 0xbc, 0xcc,
> + 0x53, 0x27, 0x8b, 0x07, 0x5f, 0xfc, 0x91, 0x29,
> + 0x82, 0x80, 0x59, 0x0a, 0x3c, 0xea, 0xc4, 0x7e,
> + 0xad, 0xd2, 0x70, 0x46, 0xbd, 0x9e, 0x3b, 0x1c,
> + 0x8a, 0x62, 0xea, 0x69, 0xbd, 0xf6, 0x96, 0x15,
> + 0xb5, 0x57, 0xe8, 0x63, 0x5f, 0x65, 0x46, 0x84,
> + 0x58, 0x50, 0x87, 0x4b, 0x0e, 0x5b, 0x52, 0x90,
> + 0xb0, 0xae, 0x37, 0x0f, 0xdd, 0x7e, 0xa2, 0xa0,
> + 0x8b, 0x78, 0xc8, 0x5a, 0x1f, 0x53, 0xdb, 0xc5,
> + 0xbf, 0x73, 0x20, 0xa9, 0x44, 0xfb, 0x1e, 0xc7,
> + 0x97, 0xb2, 0x3a, 0x5a, 0x17, 0xe6, 0x8b, 0x9b,
> + 0xe8, 0xf8, 0x2a, 0x01, 0x27, 0xa3, 0x71, 0x28,
> + 0xe3, 0x19, 0xc6, 0xaf, 0xf5, 0x3a, 0x26, 0xc0,
> + 0x5c, 0x69, 0x30, 0x78, 0x75, 0x27, 0xf2, 0x0c,
> + 0x22, 0x71, 0x65, 0xc6, 0x8e, 0x7b, 0x47, 0xe3,
> + 0x31, 0xaf, 0x7b, 0xc6, 0xc2, 0x55, 0x68, 0x81,
> + 0xaa, 0x1b, 0x21, 0x65, 0xfb, 0x18, 0x35, 0x45,
> + 0x36, 0x9a, 0x44, 0xba, 0x5c, 0xff, 0x06, 0xde,
> + 0x3a, 0xc8, 0x44, 0x0b, 0xaa, 0x8e, 0x34, 0xe2,
> + 0x84, 0xac, 0x18, 0xfe, 0x9b, 0xe1, 0x4f, 0xaa,
> + 0xb6, 0x90, 0x0b, 0x1c, 0x2c, 0xd9, 0x9a, 0x10,
> + 0x18, 0xf9, 0x49, 0x41, 0x42, 0x1b, 0xb5, 0xe1,
> + 0x26, 0xac, 0x2d, 0x38, 0x00, 0x00, 0xe4, 0xb4,
> + 0x50, 0x6f, 0x14, 0x18, 0xd6, 0x3d, 0x00, 0x59,
> + 0x3c, 0x45, 0xf3, 0x42, 0x13, 0x44, 0xb8, 0x57,
> + 0xd4, 0x43, 0x5c, 0x8a, 0x2a, 0xb4, 0xfc, 0x0a,
> + 0x25, 0x5a, 0xdc, 0x8f, 0x11, 0x0b, 0x11, 0x44,
> + 0xc7, 0x0e, 0x54, 0x8b, 0x22, 0x01, 0x7e, 0x67,
> + 0x2e, 0x15, 0x3a, 0xb9, 0xee, 0x84, 0x10, 0xd4,
> + 0x80, 0x57, 0xd7, 0x75, 0xcf, 0x8b, 0xcb, 0x03,
> + 0xc9, 0x92, 0x2b, 0x69, 0xd8, 0x5a, 0x9b, 0x06,
> + 0x85, 0x47, 0xaa, 0x4c, 0x28, 0xde, 0x49, 0x58,
> + 0xe6, 0x11, 0x1e, 0x5e, 0x64, 0x8e, 0x3b, 0xe0,
> + 0x40, 0x2e, 0xac, 0x96, 0x97, 0x15, 0x37, 0x1e,
> + 0x30, 0xdd
> +};
> +static const u8 key73[] __initconst = {
> + 0x96, 0x06, 0x1e, 0xc1, 0x6d, 0xba, 0x49, 0x5b,
> + 0x65, 0x80, 0x79, 0xdd, 0xf3, 0x67, 0xa8, 0x6e,
> + 0x2d, 0x9c, 0x54, 0x46, 0xd8, 0x4a, 0xeb, 0x7e,
> + 0x23, 0x86, 0x51, 0xd8, 0x49, 0x49, 0x56, 0xe0
> +};
> +enum { nonce73 = 0xbefb83cb67e11ffdULL };
> +
> +static const u8 input74[] __initconst = {
> + 0x47, 0x22, 0x70, 0xe5, 0x2f, 0x41, 0x18, 0x45,
> + 0x07, 0xd3, 0x6d, 0x32, 0x0d, 0x43, 0x92, 0x2b,
> + 0x9b, 0x65, 0x73, 0x13, 0x1a, 0x4f, 0x49, 0x8f,
> + 0xff, 0xf8, 0xcc, 0xae, 0x15, 0xab, 0x9d, 0x7d,
> + 0xee, 0x22, 0x5d, 0x8b, 0xde, 0x81, 0x5b, 0x81,
> + 0x83, 0x49, 0x35, 0x9b, 0xb4, 0xbc, 0x4e, 0x01,
> + 0xc2, 0x29, 0xa7, 0xf1, 0xca, 0x3a, 0xce, 0x3f,
> + 0xf5, 0x31, 0x93, 0xa8, 0xe2, 0xc9, 0x7d, 0x03,
> + 0x26, 0xa4, 0xbc, 0xa8, 0x9c, 0xb9, 0x68, 0xf3,
> + 0xb3, 0x91, 0xe8, 0xe6, 0xc7, 0x2b, 0x1a, 0xce,
> + 0xd2, 0x41, 0x53, 0xbd, 0xa3, 0x2c, 0x54, 0x94,
> + 0x21, 0xa1, 0x40, 0xae, 0xc9, 0x0c, 0x11, 0x92,
> + 0xfd, 0x91, 0xa9, 0x40, 0xca, 0xde, 0x21, 0x4e,
> + 0x1e, 0x3d, 0xcc, 0x2c, 0x87, 0x11, 0xef, 0x46,
> + 0xed, 0x52, 0x03, 0x11, 0x19, 0x43, 0x25, 0xc7,
> + 0x0d, 0xc3, 0x37, 0x5f, 0xd3, 0x6f, 0x0c, 0x6a,
> + 0x45, 0x30, 0x88, 0xec, 0xf0, 0x21, 0xef, 0x1d,
> + 0x7b, 0x38, 0x63, 0x4b, 0x49, 0x0c, 0x72, 0xf6,
> + 0x4c, 0x40, 0xc3, 0xcc, 0x03, 0xa7, 0xae, 0xa8,
> + 0x8c, 0x37, 0x03, 0x1c, 0x11, 0xae, 0x0d, 0x1b,
> + 0x62, 0x97, 0x27, 0xfc, 0x56, 0x4b, 0xb7, 0xfd,
> + 0xbc, 0xfb, 0x0e, 0xfc, 0x61, 0xad, 0xc6, 0xb5,
> + 0x9c, 0x8c, 0xc6, 0x38, 0x27, 0x91, 0x29, 0x3d,
> + 0x29, 0xc8, 0x37, 0xc9, 0x96, 0x69, 0xe3, 0xdc,
> + 0x3e, 0x61, 0x35, 0x9b, 0x99, 0x4f, 0xb9, 0x4e,
> + 0x5a, 0x29, 0x1c, 0x2e, 0xcf, 0x16, 0xcb, 0x69,
> + 0x87, 0xe4, 0x1a, 0xc4, 0x6e, 0x78, 0x43, 0x00,
> + 0x03, 0xb2, 0x8b, 0x03, 0xd0, 0xb4, 0xf1, 0xd2,
> + 0x7d, 0x2d, 0x7e, 0xfc, 0x19, 0x66, 0x5b, 0xa3,
> + 0x60, 0x3f, 0x9d, 0xbd, 0xfa, 0x3e, 0xca, 0x7b,
> + 0x26, 0x08, 0x19, 0x16, 0x93, 0x5d, 0x83, 0xfd,
> + 0xf9, 0x21, 0xc6, 0x31, 0x34, 0x6f, 0x0c, 0xaa,
> + 0x28, 0xf9, 0x18, 0xa2, 0xc4, 0x78, 0x3b, 0x56,
> + 0xc0, 0x88, 0x16, 0xba, 0x22, 0x2c, 0x07, 0x2f,
> + 0x70, 0xd0, 0xb0, 0x46, 0x35, 0xc7, 0x14, 0xdc,
> + 0xbb, 0x56, 0x23, 0x1e, 0x36, 0x36, 0x2d, 0x73,
> + 0x78, 0xc7, 0xce, 0xf3, 0x58, 0xf7, 0x58, 0xb5,
> + 0x51, 0xff, 0x33, 0x86, 0x0e, 0x3b, 0x39, 0xfb,
> + 0x1a, 0xfd, 0xf8, 0x8b, 0x09, 0x33, 0x1b, 0x83,
> + 0xf2, 0xe6, 0x38, 0x37, 0xef, 0x47, 0x84, 0xd9,
> + 0x82, 0x77, 0x2b, 0x82, 0xcc, 0xf9, 0xee, 0x94,
> + 0x71, 0x78, 0x81, 0xc8, 0x4d, 0x91, 0xd7, 0x35,
> + 0x29, 0x31, 0x30, 0x5c, 0x4a, 0x23, 0x23, 0xb1,
> + 0x38, 0x6b, 0xac, 0x22, 0x3f, 0x80, 0xc7, 0xe0,
> + 0x7d, 0xfa, 0x76, 0x47, 0xd4, 0x6f, 0x93, 0xa0,
> + 0xa0, 0x93, 0x5d, 0x68, 0xf7, 0x43, 0x25, 0x8f,
> + 0x1b, 0xc7, 0x87, 0xea, 0x59, 0x0c, 0xa2, 0xfa,
> + 0xdb, 0x2f, 0x72, 0x43, 0xcf, 0x90, 0xf1, 0xd6,
> + 0x58, 0xf3, 0x17, 0x6a, 0xdf, 0xb3, 0x4e, 0x0e,
> + 0x38, 0x24, 0x48, 0x1f, 0xb7, 0x01, 0xec, 0x81,
> + 0xb1, 0x87, 0x5b, 0xec, 0x9c, 0x11, 0x1a, 0xff,
> + 0xa5, 0xca, 0x5a, 0x63, 0x31, 0xb2, 0xe4, 0xc6,
> + 0x3c, 0x1d, 0xaf, 0x27, 0xb2, 0xd4, 0x19, 0xa2,
> + 0xcc, 0x04, 0x92, 0x42, 0xd2, 0xc1, 0x8c, 0x3b,
> + 0xce, 0xf5, 0x74, 0xc1, 0x81, 0xf8, 0x20, 0x23,
> + 0x6f, 0x20, 0x6d, 0x78, 0x36, 0x72, 0x2c, 0x52,
> + 0xdf, 0x5e, 0xe8, 0x75, 0xce, 0x1c, 0x49, 0x9d,
> + 0x93, 0x6f, 0x65, 0xeb, 0xb1, 0xbd, 0x8e, 0x5e,
> + 0xe5, 0x89, 0xc4, 0x8a, 0x81, 0x3d, 0x9a, 0xa7,
> + 0x11, 0x82, 0x8e, 0x38, 0x5b, 0x5b, 0xca, 0x7d,
> + 0x4b, 0x72, 0xc2, 0x9c, 0x30, 0x5e, 0x7f, 0xc0,
> + 0x6f, 0x91, 0xd5, 0x67, 0x8c, 0x3e, 0xae, 0xda,
> + 0x2b, 0x3c, 0x53, 0xcc, 0x50, 0x97, 0x36, 0x0b,
> + 0x79, 0xd6, 0x73, 0x6e, 0x7d, 0x42, 0x56, 0xe1,
> + 0xaa, 0xfc, 0xb3, 0xa7, 0xc8, 0x01, 0xaa, 0xc1,
> + 0xfc, 0x5c, 0x72, 0x8e, 0x63, 0xa8, 0x46, 0x18,
> + 0xee, 0x11, 0xe7, 0x30, 0x09, 0x83, 0x6c, 0xd9,
> + 0xf4, 0x7a, 0x7b, 0xb5, 0x1f, 0x6d, 0xc7, 0xbc,
> + 0xcb, 0x55, 0xea, 0x40, 0x58, 0x7a, 0x00, 0x00,
> + 0x90, 0x60, 0xc5, 0x64, 0x69, 0x05, 0x99, 0xd2,
> + 0x49, 0x62, 0x4f, 0xcb, 0x97, 0xdf, 0xdd, 0x6b,
> + 0x60, 0x75, 0xe2, 0xe0, 0x6f, 0x76, 0xd0, 0x37,
> + 0x67, 0x0a, 0xcf, 0xff, 0xc8, 0x61, 0x84, 0x14,
> + 0x80, 0x7c, 0x1d, 0x31, 0x8d, 0x90, 0xde, 0x0b,
> + 0x1c, 0x74, 0x9f, 0x82, 0x96, 0x80, 0xda, 0xaf,
> + 0x8d, 0x99, 0x86, 0x9f, 0x24, 0x99, 0x28, 0x3e,
> + 0xe0, 0xa3, 0xc3, 0x90, 0x2d, 0x14, 0x65, 0x1e,
> + 0x3b, 0xb9, 0xba, 0x13, 0xa5, 0x77, 0x73, 0x63,
> + 0x9a, 0x06, 0x3d, 0xa9, 0x28, 0x9b, 0xba, 0x25,
> + 0x61, 0xc9, 0xcd, 0xcf, 0x7a, 0x4d, 0x96, 0x09,
> + 0xcb, 0xca, 0x03, 0x9c, 0x54, 0x34, 0x31, 0x85,
> + 0xa0, 0x3d, 0xe5, 0xbc, 0xa5, 0x5f, 0x1b, 0xd3,
> + 0x10, 0x63, 0x74, 0x9d, 0x01, 0x92, 0x88, 0xf0,
> + 0x27, 0x9c, 0x28, 0xd9, 0xfd, 0xe2, 0x4e, 0x01,
> + 0x8d, 0x61, 0x79, 0x60, 0x61, 0x5b, 0x76, 0xab,
> + 0x06, 0xd3, 0x44, 0x87, 0x43, 0x52, 0xcd, 0x06,
> + 0x68, 0x1e, 0x2d, 0xc5, 0xb0, 0x07, 0x25, 0xdf,
> + 0x0a, 0x50, 0xd7, 0xd9, 0x08, 0x53, 0x65, 0xf1,
> + 0x0c, 0x2c, 0xde, 0x3f, 0x9d, 0x03, 0x1f, 0xe1,
> + 0x49, 0x43, 0x3c, 0x83, 0x81, 0x37, 0xf8, 0xa2,
> + 0x0b, 0xf9, 0x61, 0x1c, 0xc1, 0xdb, 0x79, 0xbc,
> + 0x64, 0xce, 0x06, 0x4e, 0x87, 0x89, 0x62, 0x73,
> + 0x51, 0xbc, 0xa4, 0x32, 0xd4, 0x18, 0x62, 0xab,
> + 0x65, 0x7e, 0xad, 0x1e, 0x91, 0xa3, 0xfa, 0x2d,
> + 0x58, 0x9e, 0x2a, 0xe9, 0x74, 0x44, 0x64, 0x11,
> + 0xe6, 0xb6, 0xb3, 0x00, 0x7e, 0xa3, 0x16, 0xef,
> + 0x72
> +};
> +static const u8 output74[] __initconst = {
> + 0xf5, 0xca, 0x45, 0x65, 0x50, 0x35, 0x47, 0x67,
> + 0x6f, 0x4f, 0x67, 0xff, 0x34, 0xd9, 0xc3, 0x37,
> + 0x2a, 0x26, 0xb0, 0x4f, 0x08, 0x1e, 0x45, 0x13,
> + 0xc7, 0x2c, 0x14, 0x75, 0x33, 0xd8, 0x8e, 0x1e,
> + 0x1b, 0x11, 0x0d, 0x97, 0x04, 0x33, 0x8a, 0xe4,
> + 0xd8, 0x8d, 0x0e, 0x12, 0x8d, 0xdb, 0x6e, 0x02,
> + 0xfa, 0xe5, 0xbd, 0x3a, 0xb5, 0x28, 0x07, 0x7d,
> + 0x20, 0xf0, 0x12, 0x64, 0x83, 0x2f, 0x59, 0x79,
> + 0x17, 0x88, 0x3c, 0x2d, 0x08, 0x2f, 0x55, 0xda,
> + 0xcc, 0x02, 0x3a, 0x82, 0xcd, 0x03, 0x94, 0xdf,
> + 0xdf, 0xab, 0x8a, 0x13, 0xf5, 0xe6, 0x74, 0xdf,
> + 0x7b, 0xe2, 0xab, 0x34, 0xbc, 0x00, 0x85, 0xbf,
> + 0x5a, 0x48, 0xc8, 0xff, 0x8d, 0x6c, 0x27, 0x48,
> + 0x19, 0x2d, 0x08, 0xfa, 0x82, 0x62, 0x39, 0x55,
> + 0x32, 0x11, 0xa8, 0xd7, 0xb9, 0x08, 0x2c, 0xd6,
> + 0x7a, 0xd9, 0x83, 0x9f, 0x9b, 0xfb, 0xec, 0x3a,
> + 0xd1, 0x08, 0xc7, 0xad, 0xdc, 0x98, 0x4c, 0xbc,
> + 0x98, 0xeb, 0x36, 0xb0, 0x39, 0xf4, 0x3a, 0xd6,
> + 0x53, 0x02, 0xa0, 0xa9, 0x73, 0xa1, 0xca, 0xef,
> + 0xd8, 0xd2, 0xec, 0x0e, 0xf8, 0xf5, 0xac, 0x8d,
> + 0x34, 0x41, 0x06, 0xa8, 0xc6, 0xc3, 0x31, 0xbc,
> + 0xe5, 0xcc, 0x7e, 0x72, 0x63, 0x59, 0x3e, 0x63,
> + 0xc2, 0x8d, 0x2b, 0xd5, 0xb9, 0xfd, 0x1e, 0x31,
> + 0x69, 0x32, 0x05, 0xd6, 0xde, 0xc9, 0xe6, 0x4c,
> + 0xac, 0x68, 0xf7, 0x1f, 0x9d, 0xcd, 0x0e, 0xa2,
> + 0x15, 0x3d, 0xd6, 0x47, 0x99, 0xab, 0x08, 0x5f,
> + 0x28, 0xc3, 0x4c, 0xc2, 0xd5, 0xdd, 0x10, 0xb7,
> + 0xbd, 0xdb, 0x9b, 0xcf, 0x85, 0x27, 0x29, 0x76,
> + 0x98, 0xeb, 0xad, 0x31, 0x64, 0xe7, 0xfb, 0x61,
> + 0xe0, 0xd8, 0x1a, 0xa6, 0xe2, 0xe7, 0x43, 0x42,
> + 0x77, 0xc9, 0x82, 0x00, 0xac, 0x85, 0xe0, 0xa2,
> + 0xd4, 0x62, 0xe3, 0xb7, 0x17, 0x6e, 0xb2, 0x9e,
> + 0x21, 0x58, 0x73, 0xa9, 0x53, 0x2d, 0x3c, 0xe1,
> + 0xdd, 0xd6, 0x6e, 0x92, 0xf2, 0x1d, 0xc2, 0x22,
> + 0x5f, 0x9a, 0x7e, 0xd0, 0x52, 0xbf, 0x54, 0x19,
> + 0xd7, 0x80, 0x63, 0x3e, 0xd0, 0x08, 0x2d, 0x37,
> + 0x0c, 0x15, 0xf7, 0xde, 0xab, 0x2b, 0xe3, 0x16,
> + 0x21, 0x3a, 0xee, 0xa5, 0xdc, 0xdf, 0xde, 0xa3,
> + 0x69, 0xcb, 0xfd, 0x92, 0x89, 0x75, 0xcf, 0xc9,
> + 0x8a, 0xa4, 0xc8, 0xdd, 0xcc, 0x21, 0xe6, 0xfe,
> + 0x9e, 0x43, 0x76, 0xb2, 0x45, 0x22, 0xb9, 0xb5,
> + 0xac, 0x7e, 0x3d, 0x26, 0xb0, 0x53, 0xc8, 0xab,
> + 0xfd, 0xea, 0x2c, 0xd1, 0x44, 0xc5, 0x60, 0x1b,
> + 0x8a, 0x99, 0x0d, 0xa5, 0x0e, 0x67, 0x6e, 0x3a,
> + 0x96, 0x55, 0xec, 0xe8, 0xcc, 0xbe, 0x49, 0xd9,
> + 0xf2, 0x72, 0x9f, 0x30, 0x21, 0x97, 0x57, 0x19,
> + 0xbe, 0x5e, 0x33, 0x0c, 0xee, 0xc0, 0x72, 0x0d,
> + 0x2e, 0xd1, 0xe1, 0x52, 0xc2, 0xea, 0x41, 0xbb,
> + 0xe1, 0x6d, 0xd4, 0x17, 0xa9, 0x8d, 0x89, 0xa9,
> + 0xd6, 0x4b, 0xc6, 0x4c, 0xf2, 0x88, 0x97, 0x54,
> + 0x3f, 0x4f, 0x57, 0xb7, 0x37, 0xf0, 0x2c, 0x11,
> + 0x15, 0x56, 0xdb, 0x28, 0xb5, 0x16, 0x84, 0x66,
> + 0xce, 0x45, 0x3f, 0x61, 0x75, 0xb6, 0xbe, 0x00,
> + 0xd1, 0xe4, 0xf5, 0x27, 0x54, 0x7f, 0xc2, 0xf1,
> + 0xb3, 0x32, 0x9a, 0xe8, 0x07, 0x02, 0xf3, 0xdb,
> + 0xa9, 0xd1, 0xc2, 0xdf, 0xee, 0xad, 0xe5, 0x8a,
> + 0x3c, 0xfa, 0x67, 0xec, 0x6b, 0xa4, 0x08, 0xfe,
> + 0xba, 0x5a, 0x58, 0x0b, 0x78, 0x11, 0x91, 0x76,
> + 0xe3, 0x1a, 0x28, 0x54, 0x5e, 0xbd, 0x71, 0x1b,
> + 0x8b, 0xdc, 0x6c, 0xf4, 0x6f, 0xd7, 0xf4, 0xf3,
> + 0xe1, 0x03, 0xa4, 0x3c, 0x8d, 0x91, 0x2e, 0xba,
> + 0x5f, 0x7f, 0x8c, 0xaf, 0x69, 0x89, 0x29, 0x0a,
> + 0x5b, 0x25, 0x13, 0xc4, 0x2e, 0x16, 0xc2, 0x15,
> + 0x07, 0x5d, 0x58, 0x33, 0x7c, 0xe0, 0xf0, 0x55,
> + 0x5f, 0xbf, 0x5e, 0xf0, 0x71, 0x48, 0x8f, 0xf7,
> + 0x48, 0xb3, 0xf7, 0x0d, 0xa1, 0xd0, 0x63, 0xb1,
> + 0xad, 0xae, 0xb5, 0xb0, 0x5f, 0x71, 0xaf, 0x24,
> + 0x8b, 0xb9, 0x1c, 0x44, 0xd2, 0x1a, 0x53, 0xd1,
> + 0xd5, 0xb4, 0xa9, 0xff, 0x88, 0x73, 0xb5, 0xaa,
> + 0x15, 0x32, 0x5f, 0x59, 0x9d, 0x2e, 0xb5, 0xcb,
> + 0xde, 0x21, 0x2e, 0xe9, 0x35, 0xed, 0xfd, 0x0f,
> + 0xb6, 0xbb, 0xe6, 0x4b, 0x16, 0xf1, 0x45, 0x1e,
> + 0xb4, 0x84, 0xe9, 0x58, 0x1c, 0x0c, 0x95, 0xc0,
> + 0xcf, 0x49, 0x8b, 0x59, 0xa1, 0x78, 0xe6, 0x80,
> + 0x12, 0x49, 0x7a, 0xd4, 0x66, 0x62, 0xdf, 0x9c,
> + 0x18, 0xc8, 0x8c, 0xda, 0xc1, 0xa6, 0xbc, 0x65,
> + 0x28, 0xd2, 0xa4, 0xe8, 0xf1, 0x35, 0xdb, 0x5a,
> + 0x75, 0x1f, 0x73, 0x60, 0xec, 0xa8, 0xda, 0x5a,
> + 0x43, 0x15, 0x83, 0x9b, 0xe7, 0xb1, 0xa6, 0x81,
> + 0xbb, 0xef, 0xf3, 0x8f, 0x0f, 0xd3, 0x79, 0xa2,
> + 0xe5, 0xaa, 0x42, 0xef, 0xa0, 0x13, 0x4e, 0x91,
> + 0x2d, 0xcb, 0x61, 0x7a, 0x9a, 0x33, 0x14, 0x50,
> + 0x77, 0x4a, 0xd0, 0x91, 0x48, 0xe0, 0x0c, 0xe0,
> + 0x11, 0xcb, 0xdf, 0xb0, 0xce, 0x06, 0xd2, 0x79,
> + 0x4d, 0x69, 0xb9, 0xc9, 0x36, 0x74, 0x8f, 0x81,
> + 0x72, 0x73, 0xf3, 0x17, 0xb7, 0x13, 0xcb, 0x5b,
> + 0xd2, 0x5c, 0x33, 0x61, 0xb7, 0x61, 0x79, 0xb0,
> + 0xc0, 0x4d, 0xa1, 0xc7, 0x5d, 0x98, 0xc9, 0xe1,
> + 0x98, 0xbd, 0x78, 0x5a, 0x2c, 0x64, 0x53, 0xaf,
> + 0xaf, 0x66, 0x51, 0x47, 0xe4, 0x48, 0x66, 0x8b,
> + 0x07, 0x52, 0xa3, 0x03, 0x93, 0x28, 0xad, 0xcc,
> + 0xa3, 0x86, 0xad, 0x63, 0x04, 0x35, 0x6c, 0x49,
> + 0xd5, 0x28, 0x0e, 0x00, 0x47, 0xf4, 0xd4, 0x32,
> + 0x27, 0x19, 0xb3, 0x29, 0xe7, 0xbc, 0xbb, 0xce,
> + 0x3e, 0x3e, 0xd5, 0x67, 0x20, 0xe4, 0x0b, 0x75,
> + 0x95, 0x24, 0xe0, 0x6c, 0xb6, 0x29, 0x0c, 0x14,
> + 0xfd
> +};
> +static const u8 key74[] __initconst = {
> + 0xf0, 0x41, 0x5b, 0x00, 0x56, 0xc4, 0xac, 0xf6,
> + 0xa2, 0x4c, 0x33, 0x41, 0x16, 0x09, 0x1b, 0x8e,
> + 0x4d, 0xe8, 0x8c, 0xd9, 0x48, 0xab, 0x3e, 0x60,
> + 0xcb, 0x49, 0x3e, 0xaf, 0x2b, 0x8b, 0xc8, 0xf0
> +};
> +enum { nonce74 = 0xcbdb0ffd0e923384ULL };
> +
> +static const struct chacha20_testvec chacha20_testvecs[] __initconst = {
> + { input01, output01, key01, nonce01, sizeof(input01) },
> + { input02, output02, key02, nonce02, sizeof(input02) },
> + { input03, output03, key03, nonce03, sizeof(input03) },
> + { input04, output04, key04, nonce04, sizeof(input04) },
> + { input05, output05, key05, nonce05, sizeof(input05) },
> + { input06, output06, key06, nonce06, sizeof(input06) },
> + { input07, output07, key07, nonce07, sizeof(input07) },
> + { input08, output08, key08, nonce08, sizeof(input08) },
> + { input09, output09, key09, nonce09, sizeof(input09) },
> + { input10, output10, key10, nonce10, sizeof(input10) },
> + { input11, output11, key11, nonce11, sizeof(input11) },
> + { input12, output12, key12, nonce12, sizeof(input12) },
> + { input13, output13, key13, nonce13, sizeof(input13) },
> + { input14, output14, key14, nonce14, sizeof(input14) },
> + { input15, output15, key15, nonce15, sizeof(input15) },
> + { input16, output16, key16, nonce16, sizeof(input16) },
> + { input17, output17, key17, nonce17, sizeof(input17) },
> + { input18, output18, key18, nonce18, sizeof(input18) },
> + { input19, output19, key19, nonce19, sizeof(input19) },
> + { input20, output20, key20, nonce20, sizeof(input20) },
> + { input21, output21, key21, nonce21, sizeof(input21) },
> + { input22, output22, key22, nonce22, sizeof(input22) },
> + { input23, output23, key23, nonce23, sizeof(input23) },
> + { input24, output24, key24, nonce24, sizeof(input24) },
> + { input25, output25, key25, nonce25, sizeof(input25) },
> + { input26, output26, key26, nonce26, sizeof(input26) },
> + { input27, output27, key27, nonce27, sizeof(input27) },
> + { input28, output28, key28, nonce28, sizeof(input28) },
> + { input29, output29, key29, nonce29, sizeof(input29) },
> + { input30, output30, key30, nonce30, sizeof(input30) },
> + { input31, output31, key31, nonce31, sizeof(input31) },
> + { input32, output32, key32, nonce32, sizeof(input32) },
> + { input33, output33, key33, nonce33, sizeof(input33) },
> + { input34, output34, key34, nonce34, sizeof(input34) },
> + { input35, output35, key35, nonce35, sizeof(input35) },
> + { input36, output36, key36, nonce36, sizeof(input36) },
> + { input37, output37, key37, nonce37, sizeof(input37) },
> + { input38, output38, key38, nonce38, sizeof(input38) },
> + { input39, output39, key39, nonce39, sizeof(input39) },
> + { input40, output40, key40, nonce40, sizeof(input40) },
> + { input41, output41, key41, nonce41, sizeof(input41) },
> + { input42, output42, key42, nonce42, sizeof(input42) },
> + { input43, output43, key43, nonce43, sizeof(input43) },
> + { input44, output44, key44, nonce44, sizeof(input44) },
> + { input45, output45, key45, nonce45, sizeof(input45) },
> + { input46, output46, key46, nonce46, sizeof(input46) },
> + { input47, output47, key47, nonce47, sizeof(input47) },
> + { input48, output48, key48, nonce48, sizeof(input48) },
> + { input49, output49, key49, nonce49, sizeof(input49) },
> + { input50, output50, key50, nonce50, sizeof(input50) },
> + { input51, output51, key51, nonce51, sizeof(input51) },
> + { input52, output52, key52, nonce52, sizeof(input52) },
> + { input53, output53, key53, nonce53, sizeof(input53) },
> + { input54, output54, key54, nonce54, sizeof(input54) },
> + { input55, output55, key55, nonce55, sizeof(input55) },
> + { input56, output56, key56, nonce56, sizeof(input56) },
> + { input57, output57, key57, nonce57, sizeof(input57) },
> + { input58, output58, key58, nonce58, sizeof(input58) },
> + { input59, output59, key59, nonce59, sizeof(input59) },
> + { input60, output60, key60, nonce60, sizeof(input60) },
> + { input61, output61, key61, nonce61, sizeof(input61) },
> + { input62, output62, key62, nonce62, sizeof(input62) },
> + { input63, output63, key63, nonce63, sizeof(input63) },
> + { input64, output64, key64, nonce64, sizeof(input64) },
> + { input65, output65, key65, nonce65, sizeof(input65) },
> + { input66, output66, key66, nonce66, sizeof(input66) },
> + { input67, output67, key67, nonce67, sizeof(input67) },
> + { input68, output68, key68, nonce68, sizeof(input68) },
> + { input69, output69, key69, nonce69, sizeof(input69) },
> + { input70, output70, key70, nonce70, sizeof(input70) },
> + { input71, output71, key71, nonce71, sizeof(input71) },
> + { input72, output72, key72, nonce72, sizeof(input72) },
> + { input73, output73, key73, nonce73, sizeof(input73) },
> + { input74, output74, key74, nonce74, sizeof(input74) }
> +};
> +
> +static const struct hchacha20_testvec hchacha20_testvecs[] __initconst = {{
> + .key = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
> + 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
> + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
> + 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f },
> + .nonce = { 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x4a,
> + 0x00, 0x00, 0x00, 0x00, 0x31, 0x41, 0x59, 0x27 },
> + .output = { 0x82, 0x41, 0x3b, 0x42, 0x27, 0xb2, 0x7b, 0xfe,
> + 0xd3, 0x0e, 0x42, 0x50, 0x8a, 0x87, 0x7d, 0x73,
> + 0xa0, 0xf9, 0xe4, 0xd5, 0x8a, 0x74, 0xa8, 0x53,
> + 0xc1, 0x2e, 0xc4, 0x13, 0x26, 0xd3, 0xec, 0xdc }
> +}};
> +
> +static bool __init chacha20_selftest(void)
> +{
> + enum { MAXIMUM_TEST_BUFFER_LEN = 1UL << 10 };
> + size_t i, j, k;
> + u32 derived_key[CHACHA20_KEY_WORDS];
> + u8 *offset_input = NULL, *computed_output = NULL;
> + u8 offset_key[CHACHA20_KEY_SIZE + 1]
> + __aligned(__alignof__(unsigned long));
> + struct chacha20_ctx state;
> + bool success = true;
> + simd_context_t simd_context;
> +
> + offset_input = kmalloc(MAXIMUM_TEST_BUFFER_LEN + 1, GFP_KERNEL);
> + computed_output = kmalloc(MAXIMUM_TEST_BUFFER_LEN + 1, GFP_KERNEL);
> + if (!computed_output || !offset_input) {
> + pr_info("chacha20 self-test malloc: FAIL\n");
> + success = false;
> + goto out;
> + }
> +
> + simd_get(&simd_context);
> + for (i = 0; i < ARRAY_SIZE(chacha20_testvecs); ++i) {
> + /* Boring case */
> + memset(computed_output, 0, MAXIMUM_TEST_BUFFER_LEN + 1);
> + memset(&state, 0, sizeof(state));
> + chacha20_init(&state, chacha20_testvecs[i].key,
> + chacha20_testvecs[i].nonce);
> + chacha20(&state, computed_output, chacha20_testvecs[i].input,
> + chacha20_testvecs[i].ilen, &simd_context);
> + if (memcmp(computed_output, chacha20_testvecs[i].output,
> + chacha20_testvecs[i].ilen)) {
> + pr_info("chacha20 self-test %zu: FAIL\n", i + 1);
> + success = false;
> + }
> + for (k = chacha20_testvecs[i].ilen;
> + k < MAXIMUM_TEST_BUFFER_LEN + 1; ++k) {
> + if (computed_output[k]) {
> + pr_info("chacha20 self-test %zu (zero check): FAIL\n",
> + i + 1);
> + success = false;
> + }
> + }
> +
> + /* Unaligned case */
> + memset(computed_output, 0, MAXIMUM_TEST_BUFFER_LEN + 1);
> + memset(&state, 0, sizeof(state));
> + memcpy(offset_input + 1, chacha20_testvecs[i].input,
> + chacha20_testvecs[i].ilen);
> + memcpy(offset_key + 1, chacha20_testvecs[i].key,
> + CHACHA20_KEY_SIZE);
> + chacha20_init(&state, offset_key + 1, chacha20_testvecs[i].nonce);
> + chacha20(&state, computed_output + 1, offset_input + 1,
> + chacha20_testvecs[i].ilen, &simd_context);
> + if (memcmp(computed_output + 1, chacha20_testvecs[i].output,
> + chacha20_testvecs[i].ilen)) {
> + pr_info("chacha20 self-test %zu (unaligned): FAIL\n",
> + i + 1);
> + success = false;
> + }
> + if (computed_output[0]) {
> + pr_info("chacha20 self-test %zu (unaligned, zero check): FAIL\n",
> + i + 1);
> + success = false;
> + }
> + for (k = chacha20_testvecs[i].ilen + 1;
> + k < MAXIMUM_TEST_BUFFER_LEN + 1; ++k) {
> + if (computed_output[k]) {
> + pr_info("chacha20 self-test %zu (unaligned, zero check): FAIL\n",
> + i + 1);
> + success = false;
> + }
> + }
> +
> + /* Chunked case */
> + if (chacha20_testvecs[i].ilen <= CHACHA20_BLOCK_SIZE)
> + goto next_test;
> + memset(computed_output, 0, MAXIMUM_TEST_BUFFER_LEN + 1);
> + memset(&state, 0, sizeof(state));
> + chacha20_init(&state, chacha20_testvecs[i].key,
> + chacha20_testvecs[i].nonce);
> + chacha20(&state, computed_output, chacha20_testvecs[i].input,
> + CHACHA20_BLOCK_SIZE, &simd_context);
> + chacha20(&state, computed_output + CHACHA20_BLOCK_SIZE,
> + chacha20_testvecs[i].input + CHACHA20_BLOCK_SIZE,
> + chacha20_testvecs[i].ilen - CHACHA20_BLOCK_SIZE,
> + &simd_context);
> + if (memcmp(computed_output, chacha20_testvecs[i].output,
> + chacha20_testvecs[i].ilen)) {
> + pr_info("chacha20 self-test %zu (chunked): FAIL\n",
> + i + 1);
> + success = false;
> + }
> + for (k = chacha20_testvecs[i].ilen;
> + k < MAXIMUM_TEST_BUFFER_LEN + 1; ++k) {
> + if (computed_output[k]) {
> + pr_info("chacha20 self-test %zu (chunked, zero check): FAIL\n",
> + i + 1);
> + success = false;
> + }
> + }
> +
> +next_test:
> + /* Sliding unaligned case */
> + if (chacha20_testvecs[i].ilen > CHACHA20_BLOCK_SIZE + 1 ||
> + !chacha20_testvecs[i].ilen)
> + continue;
> + for (j = 1; j < CHACHA20_BLOCK_SIZE; ++j) {
> + memset(computed_output, 0, MAXIMUM_TEST_BUFFER_LEN + 1);
> + memset(&state, 0, sizeof(state));
> + memcpy(offset_input + j, chacha20_testvecs[i].input,
> + chacha20_testvecs[i].ilen);
> + chacha20_init(&state, chacha20_testvecs[i].key,
> + chacha20_testvecs[i].nonce);
> + chacha20(&state, computed_output + j, offset_input + j,
> + chacha20_testvecs[i].ilen, &simd_context);
> + if (memcmp(computed_output + j,
> + chacha20_testvecs[i].output,
> + chacha20_testvecs[i].ilen)) {
> + pr_info("chacha20 self-test %zu (unaligned, slide %zu): FAIL\n",
> + i + 1, j);
> + success = false;
> + }
> + for (k = j; k < j; ++k) {
> + if (computed_output[k]) {
> + pr_info("chacha20 self-test %zu (unaligned, slide %zu, zero check): FAIL\n",
> + i + 1, j);
> + success = false;
> + }
> + }
> + for (k = chacha20_testvecs[i].ilen + j;
> + k < MAXIMUM_TEST_BUFFER_LEN + 1; ++k) {
> + if (computed_output[k]) {
> + pr_info("chacha20 self-test %zu (unaligned, slide %zu, zero check): FAIL\n",
> + i + 1, j);
> + success = false;
> + }
> + }
> + }
> + }
> + for (i = 0; i < ARRAY_SIZE(hchacha20_testvecs); ++i) {
> + memset(&derived_key, 0, sizeof(derived_key));
> + hchacha20(derived_key, hchacha20_testvecs[i].nonce,
> + hchacha20_testvecs[i].key, &simd_context);
> + cpu_to_le32_array(derived_key, ARRAY_SIZE(derived_key));
> + if (memcmp(derived_key, hchacha20_testvecs[i].output,
> + CHACHA20_KEY_SIZE)) {
> + pr_info("hchacha20 self-test %zu: FAIL\n", i + 1);
> + success = false;
> + }
> + }
> + simd_put(&simd_context);
> + if (success)
> + pr_info("chacha20 self-tests: pass\n");
> +
> +out:
> + kfree(offset_input);
> + kfree(computed_output);
> + return success;
> +}
> +#endif
> --
> 2.19.0
>
^ permalink raw reply
* Re: [PATCH ethtool] ethtool: support combinations of FEC modes
From: Andrew Lunn @ 2018-09-28 15:39 UTC (permalink / raw)
To: Edward Cree
Cc: Ariel Almog, linville, Linux Netdev List, ganeshgr,
jakub.kicinski, dustin, dirk.vandermerwe, shayag, ariela
In-Reply-To: <7451b1dc-1cac-6cb2-fe56-8c09eac8aefb@solarflare.com>
> For us, those semantics make sense (our HW has a notion of 'supported'
> and 'requested' bits for each FEC type for each of local-device, cable
> and link-partner, and uses the strongest FEC mode that's supported by
> everyone and requested by anyone); but if something else is a better fit
> for your hardware I wouldn't worry too much about the inconsistency —
> people using this functionality will hopefully have read the hardware's
> user manual...
I wonder how true that will be in 5 years time, about reading the
manual? SFP sockets are starting to appear in consumer devices. There
are some Marvell SoC reference boards with SFP and SFP+. Broadcom also
have some boards with SFP. With time, SFP will move out of the data
centre and comms rack and into more everyday systems. In such context,
reading the manual becomes less likely. It would be nice to avoid a
future inconsistent mess caused be this sentiment now.
Andrew
^ permalink raw reply
* Bad MAINTAINERS pattern in section 'NETWORKING [IPSEC]'
From: Joe Perches @ 2018-09-28 22:01 UTC (permalink / raw)
To: linux-kernel
Cc: Steffen Klassert, Herbert Xu, David S . Miller, netdev,
Florian Westphal
Please fix this defect appropriately.
linux-next MAINTAINERS section:
10233 NETWORKING [IPSEC]
10234 M: Steffen Klassert <steffen.klassert@secunet.com>
10235 M: Herbert Xu <herbert@gondor.apana.org.au>
10236 M: "David S. Miller" <davem@davemloft.net>
10237 L: netdev@vger.kernel.org
10238 T: git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec.git
10239 T: git git://git.kernel.org/pub/scm/linux/kernel/git/klassert/ipsec-next.git
10240 S: Maintained
--> 10241 F: net/core/flow.c
10242 F: net/xfrm/
10243 F: net/key/
10244 F: net/ipv4/xfrm*
10245 F: net/ipv4/esp4*
10246 F: net/ipv4/ah4.c
10247 F: net/ipv4/ipcomp.c
10248 F: net/ipv4/ip_vti.c
10249 F: net/ipv6/xfrm*
10250 F: net/ipv6/esp6*
10251 F: net/ipv6/ah6.c
10252 F: net/ipv6/ipcomp6.c
10253 F: net/ipv6/ip6_vti.c
10254 F: include/uapi/linux/xfrm.h
10255 F: include/net/xfrm.h
Commit that introduced this:
commit 5826bdd1816fa2baa122b62e14905c0ad8e7b96a
Author: Fan Du <fan.du@windriver.com>
Date: Sat Jan 18 09:55:28 2014 +0800
flowcache: Bring net/core/flow.c under IPsec maintain scope
As flow cache is mainly manipulated from IPsec.
Signed-off-by: Fan Du <fan.du@windriver.com>
Signed-off-by: Steffen Klassert <steffen.klassert@secunet.com>
MAINTAINERS | 1 +
1 file changed, 1 insertion(+)
Last commit with net/core/flow.c
commit 09c7570480f7544ffbf8e6db365208b0b0c154c6
Author: Florian Westphal <fw@strlen.de>
Date: Mon Jul 17 13:57:26 2017 +0200
xfrm: remove flow cache
After rcu conversions performance degradation in forward tests isn't that
noticeable anymore.
See next patch for some numbers.
A followup patcg could then also remove genid from the policies
as we do not cache bundles anymore.
Signed-off-by: Florian Westphal <fw@strlen.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
include/net/flow.h | 34 ---
include/net/flowcache.h | 25 --
include/net/netns/xfrm.h | 11 -
include/net/xfrm.h | 8 -
net/core/Makefile | 1 -
net/core/flow.c | 516 ----------------------------------------
net/ipv4/xfrm4_policy.c | 9 -
net/ipv6/xfrm6_policy.c | 9 -
net/key/af_key.c | 6 -
net/xfrm/xfrm_device.c | 2 -
net/xfrm/xfrm_policy.c | 108 +--------
net/xfrm/xfrm_user.c | 3 -
security/selinux/include/xfrm.h | 4 +-
13 files changed, 2 insertions(+), 734 deletions(-)
^ permalink raw reply
* Bad MAINTAINERS pattern in section 'NET_FAILOVER MODULE'
From: Joe Perches @ 2018-09-28 22:01 UTC (permalink / raw)
To: linux-kernel; +Cc: Sridhar Samudrala, netdev
Please fix this defect appropriately.
linux-next MAINTAINERS section:
10085 NET_FAILOVER MODULE
10086 M: Sridhar Samudrala <sridhar.samudrala@intel.com>
10087 L: netdev@vger.kernel.org
10088 S: Supported
--> 10089 F: driver/net/net_failover.c
10090 F: include/net/net_failover.h
10091 F: Documentation/networking/net_failover.rst
Commit that introduced this:
commit cfc80d9a11635404a40199a1c9471c96890f3f74
Author: Sridhar Samudrala <sridhar.samudrala@intel.com>
Date: Thu May 24 09:55:15 2018 -0700
net: Introduce net_failover driver
The net_failover driver provides an automated failover mechanism via APIs
to create and destroy a failover master netdev and manages a primary and
standby slave netdevs that get registered via the generic failover
infrastructure.
The failover netdev acts a master device and controls 2 slave devices. The
original paravirtual interface gets registered as 'standby' slave netdev and
a passthru/vf device with the same MAC gets registered as 'primary' slave
netdev. Both 'standby' and 'failover' netdevs are associated with the same
'pci' device. The user accesses the network interface via 'failover' netdev.
The 'failover' netdev chooses 'primary' netdev as default for transmits when
it is available with link up and running.
This can be used by paravirtual drivers to enable an alternate low latency
datapath. It also enables hypervisor controlled live migration of a VM with
direct attached VF by failing over to the paravirtual datapath when the VF
is unplugged.
Signed-off-by: Sridhar Samudrala <sridhar.samudrala@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
Documentation/networking/net_failover.rst | 26 +
MAINTAINERS | 8 +
drivers/net/Kconfig | 12 +
drivers/net/Makefile | 1 +
drivers/net/net_failover.c | 836 ++++++++++++++++++++++++++++++
include/net/net_failover.h | 40 ++
6 files changed, 923 insertions(+)
No commit with driver/net/net_failover.c found
^ permalink raw reply
* Bad MAINTAINERS pattern in section 'MELLANOX ETHERNET INNOVA IPSEC DRIVER'
From: Joe Perches @ 2018-09-28 21:56 UTC (permalink / raw)
To: linux-kernel; +Cc: Boris Pismenny, netdev
Please fix this defect appropriately.
linux-next MAINTAINERS section:
9325 MELLANOX ETHERNET INNOVA IPSEC DRIVER
9326 R: Boris Pismenny <borisp@mellanox.com>
9327 L: netdev@vger.kernel.org
9328 S: Supported
9329 W: http://www.mellanox.com
9330 Q: http://patchwork.ozlabs.org/project/netdev/list/
9331 F: drivers/net/ethernet/mellanox/mlx5/core/en_ipsec/*
--> 9332 F: drivers/net/ethernet/mellanox/mlx5/core/ipsec*
Commit that introduced this:
commit 547eede070eb981f1442e494f08f4567dcf1d1c7
Author: Ilan Tayari <ilant@mellanox.com>
Date: Tue Apr 18 16:04:28 2017 +0300
net/mlx5e: IPSec, Innova IPSec offload infrastructure
Add Innova IPSec ESP crypto offload configuration paths.
Detect Innova IPSec device and set the NETIF_F_HW_ESP flag.
Configure Security Associations using the API introduced in a previous
patch.
Add Software-parser hardware descriptor layout
Software-Parser (swp) is a hardware feature in ConnectX which allows the
host software to specify protocol header offsets in the TX path, thus
overriding the hardware parser.
This is useful for protocols that the ASIC may not be able to parse on
its own.
Note that due to inline metadata, XDP is not supported in Innova IPSec.
Signed-off-by: Ilan Tayari <ilant@mellanox.com>
Signed-off-by: Yossi Kuperman <yossiku@mellanox.com>
Signed-off-by: Yevgeny Kliteynik <kliteyn@mellanox.com>
Signed-off-by: Boris Pismenny <borisp@mellanox.com>
Signed-off-by: Saeed Mahameed <saeedm@mellanox.com>
MAINTAINERS | 10 +
drivers/net/ethernet/mellanox/mlx5/core/Kconfig | 12 +
drivers/net/ethernet/mellanox/mlx5/core/Makefile | 2 +
drivers/net/ethernet/mellanox/mlx5/core/en.h | 3 +
.../ethernet/mellanox/mlx5/core/en_accel/ipsec.c | 415 +++++++++++++++++++++
.../ethernet/mellanox/mlx5/core/en_accel/ipsec.h | 78 ++++
drivers/net/ethernet/mellanox/mlx5/core/en_main.c | 14 +
include/linux/mlx5/mlx5_ifc.h | 8 +-
include/linux/mlx5/qp.h | 14 +-
9 files changed, 552 insertions(+), 4 deletions(-)
No commit with drivers/net/ethernet/mellanox/mlx5/core/ipsec* found
^ permalink raw reply
* Bad MAINTAINERS pattern in section 'MELLANOX ETHERNET INNOVA IPSEC DRIVER'
From: Joe Perches @ 2018-09-28 21:55 UTC (permalink / raw)
To: linux-kernel; +Cc: Boris Pismenny, netdev
Please fix this defect appropriately.
linux-next MAINTAINERS section:
9325 MELLANOX ETHERNET INNOVA IPSEC DRIVER
9326 R: Boris Pismenny <borisp@mellanox.com>
9327 L: netdev@vger.kernel.org
9328 S: Supported
9329 W: http://www.mellanox.com
9330 Q: http://patchwork.ozlabs.org/project/netdev/list/
--> 9331 F: drivers/net/ethernet/mellanox/mlx5/core/en_ipsec/*
9332 F: drivers/net/ethernet/mellanox/mlx5/core/ipsec*
Commit that introduced this:
commit 547eede070eb981f1442e494f08f4567dcf1d1c7
Author: Ilan Tayari <ilant@mellanox.com>
Date: Tue Apr 18 16:04:28 2017 +0300
net/mlx5e: IPSec, Innova IPSec offload infrastructure
Add Innova IPSec ESP crypto offload configuration paths.
Detect Innova IPSec device and set the NETIF_F_HW_ESP flag.
Configure Security Associations using the API introduced in a previous
patch.
Add Software-parser hardware descriptor layout
Software-Parser (swp) is a hardware feature in ConnectX which allows the
host software to specify protocol header offsets in the TX path, thus
overriding the hardware parser.
This is useful for protocols that the ASIC may not be able to parse on
its own.
Note that due to inline metadata, XDP is not supported in Innova IPSec.
Signed-off-by: Ilan Tayari <ilant@mellanox.com>
Signed-off-by: Yossi Kuperman <yossiku@mellanox.com>
Signed-off-by: Yevgeny Kliteynik <kliteyn@mellanox.com>
Signed-off-by: Boris Pismenny <borisp@mellanox.com>
Signed-off-by: Saeed Mahameed <saeedm@mellanox.com>
MAINTAINERS | 10 +
drivers/net/ethernet/mellanox/mlx5/core/Kconfig | 12 +
drivers/net/ethernet/mellanox/mlx5/core/Makefile | 2 +
drivers/net/ethernet/mellanox/mlx5/core/en.h | 3 +
.../ethernet/mellanox/mlx5/core/en_accel/ipsec.c | 415 +++++++++++++++++++++
.../ethernet/mellanox/mlx5/core/en_accel/ipsec.h | 78 ++++
drivers/net/ethernet/mellanox/mlx5/core/en_main.c | 14 +
include/linux/mlx5/mlx5_ifc.h | 8 +-
include/linux/mlx5/qp.h | 14 +-
9 files changed, 552 insertions(+), 4 deletions(-)
No commit with drivers/net/ethernet/mellanox/mlx5/core/en_ipsec/* found
^ permalink raw reply
* Bad MAINTAINERS pattern in section 'LANTIQ / INTEL Ethernet drivers'
From: Joe Perches @ 2018-09-28 21:54 UTC (permalink / raw)
To: linux-kernel; +Cc: Hauke Mehrtens, netdev
Please fix this defect appropriately.
linux-next MAINTAINERS section:
8155 LANTIQ / INTEL Ethernet drivers
8156 M: Hauke Mehrtens <hauke@hauke-m.de>
8157 L: netdev@vger.kernel.org
8158 S: Maintained
8159 F: net/dsa/tag_gswip.c
8160 F: drivers/net/ethernet/lantiq_xrx200.c
8161 F: drivers/net/dsa/lantiq_pce.h
--> 8162 F: drivers/net/dsa/intel_gswip.c
Commit that introduced this:
commit 14fceff4771e51b23b4485b575cf9e5b3414b89b
Author: Hauke Mehrtens <hauke@hauke-m.de>
Date: Sun Sep 9 22:20:39 2018 +0200
net: dsa: Add Lantiq / Intel DSA driver for vrx200
This adds the DSA driver for the GSWIP Switch found in the VRX200 SoC.
This switch is integrated in the DSL SoC, this SoC uses a GSWIP version
2.1, there are other SoCs using different versions of this IP block, but
this driver was only tested with the version found in the VRX200.
Currently only the basic features are implemented which will forward all
packages to the CPU and let the CPU do the forwarding. The hardware also
support Layer 2 offloading which is not yet implemented in this driver.
The GPHY FW loaded is now done by this driver and not any more by the
separate driver in drivers/soc/lantiq/gphy.c, I will remove this driver
is a separate patch. to make use of the GPHY this switch driver is
needed anyway. Other SoCs have more embedded GPHYs so this driver should
support a variable number of GPHYs. After the firmware was loaded the
GPHY can be probed on the MDIO bus and it behaves like an external GPHY,
without the firmware it can not be probed on the MDIO bus.
The clock names in the sysctrl.c file have to be changed because the
clocks are now used by a different driver. This should be cleaned up and
a real common clock driver should provide the clocks instead.
Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de>
Signed-off-by: David S. Miller <davem@davemloft.net>
MAINTAINERS | 2 +
arch/mips/lantiq/xway/sysctrl.c | 8 +-
drivers/net/dsa/Kconfig | 8 +
drivers/net/dsa/Makefile | 1 +
drivers/net/dsa/lantiq_gswip.c | 1169 +++++++++++++++++++++++++++++++++++++++
drivers/net/dsa/lantiq_pce.h | 153 +++++
6 files changed, 1337 insertions(+), 4 deletions(-)
No commit with drivers/net/dsa/intel_gswip.c found
^ permalink raw reply
* Bad MAINTAINERS pattern in section 'IPX NETWORK LAYER'
From: Joe Perches @ 2018-09-28 21:53 UTC (permalink / raw)
To: linux-kernel; +Cc: netdev, Greg Kroah-Hartman
Please fix this defect appropriately.
linux-next MAINTAINERS section:
7639 IPX NETWORK LAYER
7640 L: netdev@vger.kernel.org
7641 S: Obsolete
7642 F: include/uapi/linux/ipx.h
--> 7643 F: drivers/staging/ipx/
Commit that introduced this:
commit e02554e9a4338c58e75fdfb0ef908a5adc86cba5
Author: Stephen Hemminger <stephen@networkplumber.org>
Date: Tue Nov 14 08:37:14 2017 -0800
ipx: move Novell IPX protocol support into staging
The Netware IPX protocol is very old and no one should still be using
it. It is time to move it into staging for a while and eventually
decommision it.
Signed-off-by: Stephen Hemminger <stephen@networkplumber.org>
Acked-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
MAINTAINERS | 3 +--
drivers/staging/Kconfig | 2 ++
drivers/staging/Makefile | 1 +
{net => drivers/staging}/ipx/Kconfig | 0
{net => drivers/staging}/ipx/Makefile | 0
drivers/staging/ipx/TODO | 4 ++++
{net => drivers/staging}/ipx/af_ipx.c | 0
{net => drivers/staging}/ipx/ipx_proc.c | 0
{net => drivers/staging}/ipx/ipx_route.c | 0
{net => drivers/staging}/ipx/pe2.c | 0
{net => drivers/staging}/ipx/sysctl_net_ipx.c | 0
net/Kconfig | 1 -
net/Makefile | 1 -
13 files changed, 8 insertions(+), 4 deletions(-)
Last commit with drivers/staging/ipx/
commit 7a2e838d28cff6718a0bdf66164465402f8e40ed
Author: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Date: Fri Jun 1 20:39:54 2018 +0200
staging: ipx: delete it from the tree
The ipx code moved into the staging tree back in November 2017 and no
one has complained or even noticed it was gone. Because of that, let's
just delete it.
Note, the ipx header files are not removed here, that will come later
through the networking tree, as that takes a bit more work to unwind.
Cc: Stephen Hemminger <stephen@networkplumber.org>
Cc: David S. Miller <davem@davemloft.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
drivers/staging/Kconfig | 2 -
drivers/staging/Makefile | 1 -
drivers/staging/ipx/Kconfig | 61 -
drivers/staging/ipx/Makefile | 8 -
drivers/staging/ipx/TODO | 4 -
drivers/staging/ipx/af_ipx.c | 2082 ----------------------------------
drivers/staging/ipx/ipx_proc.c | 338 ------
drivers/staging/ipx/ipx_route.c | 293 -----
drivers/staging/ipx/pe2.c | 36 -
drivers/staging/ipx/sysctl_net_ipx.c | 40 -
10 files changed, 2865 deletions(-)
^ permalink raw reply
* Re: [Patch net-next v3] net_sched: change tcf_del_walker() to take idrinfo->lock
From: Ido Schimmel @ 2018-09-28 15:08 UTC (permalink / raw)
To: Cong Wang; +Cc: netdev, jiri, jhs, Vlad Buslov
In-Reply-To: <20180928145900.GA17640@splinter>
On Fri, Sep 28, 2018 at 05:59:00PM +0300, Ido Schimmel wrote:
> I'm getting a use-after-free when running tc_chains.sh selftest and I
> believe it's caused by this patch.
BTW, I can't reproduce the issue after reverting the patch.
^ permalink raw reply
* Re: [Patch net-next v3] net_sched: change tcf_del_walker() to take idrinfo->lock
From: Ido Schimmel @ 2018-09-28 14:59 UTC (permalink / raw)
To: Cong Wang; +Cc: netdev, jiri, jhs, Vlad Buslov
In-Reply-To: <20180919233729.10951-1-xiyou.wangcong@gmail.com>
On Wed, Sep 19, 2018 at 04:37:29PM -0700, Cong Wang wrote:
> From: Vlad Buslov <vladbu@mellanox.com>
>
> From: Vlad Buslov <vladbu@mellanox.com>
>
> Action API was changed to work with actions and action_idr in concurrency
> safe manner, however tcf_del_walker() still uses actions without taking a
> reference or idrinfo->lock first, and deletes them directly, disregarding
> possible concurrent delete.
>
> Change tcf_del_walker() to take idrinfo->lock while iterating over actions
> and use new tcf_idr_release_unsafe() to release them while holding the
> lock.
>
> And the blocking function fl_hw_destroy_tmplt() could be called when we
> put a filter chain, so defer it to a work queue.
I'm getting a use-after-free when running tc_chains.sh selftest and I
believe it's caused by this patch.
To reproduce:
# cd tools/testing/selftests/net/forwarding
# export TESTS="template_filter_fits"; ./tc_chains.sh veth0 veth1
__tcf_chain_put()
tc_chain_tmplt_del()
fl_tmplt_destroy()
tcf_queue_work(&tmplt->rwork, fl_tmplt_destroy_work)
tcf_chain_destroy()
kfree(chain)
Some time later fl_tmplt_destroy_work() starts executing and
dereferencing 'chain'.
Splat:
[ 48.269074] ==================================================================
[ 48.270186] BUG: KASAN: use-after-free in fl_tmplt_destroy_work+0x289/0x2d0
[ 48.271199] Read of size 8 at addr ffff880067f0d498 by task kworker/u2:1/18
[ 48.272270]
[ 48.272520] CPU: 0 PID: 18 Comm: kworker/u2:1 Not tainted 4.19.0-rc5-custom+ #917
[ 48.273683] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS ?-20180531_142017-buildhw-08.phx2.fedoraproject.org-1.fc28 04/01/2014
[ 48.275495] Workqueue: tc_filter_workqueue fl_tmplt_destroy_work
[ 48.276387] Call Trace:
[ 48.276766] dump_stack+0x10f/0x1d8
[ 48.277302] ? dump_stack_print_info.cold.0+0x20/0x20
[ 48.278080] ? printk+0xac/0xd4
[ 48.278585] ? cpumask_weight.constprop.23+0x39/0x39
[ 48.279360] print_address_description.cold.3+0x9/0x258
[ 48.280186] kasan_report.cold.4+0x6a/0x9d
[ 48.280856] __asan_report_load8_noabort+0x19/0x20
[ 48.281642] fl_tmplt_destroy_work+0x289/0x2d0
[ 48.282331] ? fl_tmplt_destroy+0x30/0x30
[ 48.282966] process_one_work+0xb5d/0x1a10
[ 48.283642] ? kasan_check_write+0x14/0x20
[ 48.284301] ? pwq_dec_nr_in_flight+0x4e0/0x4e0
[ 48.285003] ? lock_repin_lock+0x360/0x360
[ 48.285652] ? __schedule+0x86d/0x2310
[ 48.286256] ? lockdep_hardirqs_on+0x39f/0x580
[ 48.286995] ? __sched_text_start+0x8/0x8
[ 48.287654] ? lock_downgrade+0x740/0x740
[ 48.288292] ? sched_clock_local+0xe0/0x150
[ 48.288969] ? save_trace+0x340/0x340
[ 48.289526] ? save_trace+0x340/0x340
[ 48.290156] ? check_preemption_disabled+0x3b/0x210
[ 48.290937] ? find_held_lock+0x40/0x1d0
[ 48.291598] ? debug_smp_processor_id+0x1c/0x20
[ 48.292290] ? worker_thread+0x3c3/0x12b0
[ 48.292952] ? lock_contended+0x1260/0x1260
[ 48.293606] ? _raw_spin_unlock_irq+0x2c/0x50
[ 48.294311] ? do_raw_spin_trylock+0x121/0x1c0
[ 48.294982] ? do_raw_spin_lock+0x1e0/0x1e0
[ 48.295658] ? trace_hardirqs_on+0x290/0x290
[ 48.296346] worker_thread+0x18e/0x12b0
[ 48.296972] ? lock_repin_lock+0x360/0x360
[ 48.297624] ? process_one_work+0x1a10/0x1a10
[ 48.298332] ? save_trace+0x340/0x340
[ 48.298937] ? kasan_check_write+0x14/0x20
[ 48.299639] ? sched_clock_local+0xe0/0x150
[ 48.300310] ? check_preemption_disabled+0x3b/0x210
[ 48.301064] ? check_preemption_disabled+0x3b/0x210
[ 48.301848] ? find_held_lock+0x40/0x1d0
[ 48.302472] ? debug_smp_processor_id+0x1c/0x20
[ 48.303196] ? _raw_spin_unlock_irqrestore+0x57/0x70
[ 48.304037] ? _raw_spin_unlock_irqrestore+0x57/0x70
[ 48.304862] ? lockdep_hardirqs_on+0x39f/0x580
[ 48.305595] ? trace_hardirqs_on+0xa1/0x290
[ 48.306237] ? do_raw_spin_trylock+0x121/0x1c0
[ 48.306924] ? __kthread_parkme+0xdc/0x1a0
[ 48.307607] ? preempt_schedule_common+0x1f/0xd0
[ 48.308359] ? __kthread_parkme+0x5d/0x1a0
[ 48.309014] ? __kthread_parkme+0xfa/0x1a0
[ 48.309690] ? _raw_spin_unlock_irqrestore+0x60/0x70
[ 48.310461] kthread+0x34d/0x410
[ 48.310970] ? process_one_work+0x1a10/0x1a10
[ 48.311672] ? kthread_delayed_work_timer_fn+0x450/0x450
[ 48.312548] ret_from_fork+0x24/0x30
[ 48.313114]
[ 48.313390] Allocated by task 1239:
[ 48.313983] save_stack+0x43/0xd0
[ 48.314533] kasan_kmalloc+0xc4/0xe0
[ 48.315119] kmem_cache_alloc_trace+0x124/0x280
[ 48.315873] tcf_chain_create+0xa4/0x370
[ 48.316506] tc_ctl_chain+0xe3d/0x1430
[ 48.317114] rtnetlink_rcv_msg+0x3a3/0xa80
[ 48.317799] netlink_rcv_skb+0x152/0x3c0
[ 48.318440] rtnetlink_rcv+0x21/0x30
[ 48.319042] netlink_unicast+0x52f/0x740
[ 48.319675] netlink_sendmsg+0x9c7/0xf50
[ 48.320276] sock_sendmsg+0xcf/0x120
[ 48.320853] ___sys_sendmsg+0x778/0x8f0
[ 48.321445] __sys_sendmsg+0x112/0x270
[ 48.322079] __x64_sys_sendmsg+0x7d/0xc0
[ 48.322687] do_syscall_64+0x15d/0x640
[ 48.323274] entry_SYSCALL_64_after_hwframe+0x49/0xbe
[ 48.324004]
[ 48.324264] Freed by task 1248:
[ 48.324796] save_stack+0x43/0xd0
[ 48.314533] kasan_kmalloc+0xc4/0xe0
[ 48.315119] kmem_cache_alloc_trace+0x124/0x280
[ 48.315873] tcf_chain_create+0xa4/0x370
[ 48.316506] tc_ctl_chain+0xe3d/0x1430
[ 48.317114] rtnetlink_rcv_msg+0x3a3/0xa80
[ 48.317799] netlink_rcv_skb+0x152/0x3c0
[ 48.318440] rtnetlink_rcv+0x21/0x30
[ 48.319042] netlink_unicast+0x52f/0x740
[ 48.319675] netlink_sendmsg+0x9c7/0xf50
[ 48.320276] sock_sendmsg+0xcf/0x120
[ 48.320853] ___sys_sendmsg+0x778/0x8f0
[ 48.321445] __sys_sendmsg+0x112/0x270
[ 48.322079] __x64_sys_sendmsg+0x7d/0xc0
[ 48.322687] do_syscall_64+0x15d/0x640
[ 48.323274] entry_SYSCALL_64_after_hwframe+0x49/0xbe
[ 48.324004]
[ 48.324264] Freed by task 1248:
[ 48.324796] save_stack+0x43/0xd0
[ 48.325355] __kasan_slab_free+0x131/0x180
[ 48.326001] kasan_slab_free+0xe/0x10
[ 48.326579] kfree+0xd7/0x2b0
[ 48.327054] __tcf_chain_put+0x339/0x710
[ 48.327654] tc_ctl_chain+0xbde/0x1430
[ 48.328276] rtnetlink_rcv_msg+0x3a3/0xa80
[ 48.328899] netlink_rcv_skb+0x152/0x3c0
[ 48.329556] rtnetlink_rcv+0x21/0x30
[ 48.330170] netlink_unicast+0x52f/0x740
[ 48.330839] netlink_sendmsg+0x9c7/0xf50
[ 48.331491] sock_sendmsg+0xcf/0x120
[ 48.332079] ___sys_sendmsg+0x778/0x8f0
[ 48.332706] __sys_sendmsg+0x112/0x270
[ 48.333334] __x64_sys_sendmsg+0x7d/0xc0
[ 48.333957] do_syscall_64+0x15d/0x640
[ 48.334581] entry_SYSCALL_64_after_hwframe+0x49/0xbe
[ 48.335362]
[ 48.335645] The buggy address belongs to the object at ffff880067f0d480
[ 48.335645] which belongs to the cache kmalloc-64 of size 64
[ 48.337559] The buggy address is located 24 bytes inside of
[ 48.337559] 64-byte region [ffff880067f0d480, ffff880067f0d4c0)
[ 48.339313] The buggy address belongs to the page:
[ 48.340083] page:ffffea00019fc340 count:1 mapcount:0 mapping:ffff88006cc01780 index:0x0
[ 48.341330] flags: 0x100000000000100(slab)
[ 48.342000] raw: 0100000000000100 ffffea00019fce80 0000001100000011 ffff88006cc01780
[ 48.343163] raw: 0000000000000000 00000000002a002a 00000001ffffffff 0000000000000000
[ 48.344424] page dumped because: kasan: bad access detected
[ 48.345299]
[ 48.345580] Memory state around the buggy address:
[ 48.346356] ffff880067f0d380: fb fb fb fb fc fc fc fc fb fb fb fb fb fb fb fb
[ 48.347477] ffff880067f0d400: fc fc fc fc fb fb fb fb fb fb fb fb fc fc fc fc
[ 48.348645] >ffff880067f0d480: fb fb fb fb fb fb fb fb fc fc fc fc fb fb fb fb
[ 48.349799] ^
[ 48.350457] ffff880067f0d500: fb fb fb fb fc fc fc fc fb fb fb fb fb fb fb fb
[ 48.351627] ffff880067f0d580: fc fc fc fc fb fb fb fb fb fb fb fb fc fc fc fc
[ 48.352802] ==================================================================
^ permalink raw reply
* Re: KASAN: global-out-of-bounds Read in __aa_lookupn_ns
From: Dmitry Vyukov @ 2018-09-28 15:01 UTC (permalink / raw)
To: John Johansen
Cc: syzbot, James Morris, Serge E. Hallyn, linux-security-module,
David Miller, LKML, netdev, syzkaller-bugs
In-Reply-To: <23948464-72d2-7d04-59b5-79606c24ed75@canonical.com>
On Fri, Sep 28, 2018 at 3:19 PM, John Johansen
<john.johansen@canonical.com> wrote:
> On 09/28/2018 01:39 AM, Dmitry Vyukov wrote:
>> On Wed, Sep 26, 2018 at 12:06 PM, Dmitry Vyukov <dvyukov@google.com> wrote:
>>> On Wed, Sep 26, 2018 at 9:54 AM, syzbot
>>> <syzbot+71b6643475f707f93fdc@syzkaller.appspotmail.com> wrote:
>>>> Hello,
>>>>
>>>> syzbot found the following crash on:
>>>>
>>>> HEAD commit: 02214bfc89c7 Merge tag 'media/v4.19-2' of git://git.kernel..
>>>> git tree: upstream
>>>> console output: https://syzkaller.appspot.com/x/log.txt?x=1456f8a1400000
>>>> kernel config: https://syzkaller.appspot.com/x/.config?x=22a62640793a83c9
>>>> dashboard link: https://syzkaller.appspot.com/bug?extid=71b6643475f707f93fdc
>>>> compiler: gcc (GCC) 8.0.1 20180413 (experimental)
>>>>
>>>> Unfortunately, I don't have any reproducer for this crash yet.
>>>
>>> Again misattributed to net. This misattribution should now be fixed by:
>>> https://github.com/google/syzkaller/commit/db716d6653d073b0abfb51186cd4ac2d5418c9c6
>>> Adding security/apparmor/policy_ns.c maintainers explicitly.
>>
>> This is the same as "KASAN: stack-out-of-bounds Read in __aa_lookupn_ns":
>> https://syzkaller.appspot.com/bug?id=f0d603856d8b3cc9b8e09228f2f548c18ef907ac
>> right?
>>
>
> yes it looks like it is
Let's tell syzbot then, otherwise it will consider it as open forever:
#syz dup: KASAN: stack-out-of-bounds Read in __aa_lookupn_ns
>>>> IMPORTANT: if you fix the bug, please add the following tag to the commit:
>>>> Reported-by: syzbot+71b6643475f707f93fdc@syzkaller.appspotmail.com
>>>>
>>>> sock_common_setsockopt+0x9a/0xe0 net/core/sock.c:3038
>>>> __sys_setsockopt+0x1ba/0x3c0 net/socket.c:1902
>>>> __do_sys_setsockopt net/socket.c:1913 [inline]
>>>> __se_sys_setsockopt net/socket.c:1910 [inline]
>>>> __x64_sys_setsockopt+0xbe/0x150 net/socket.c:1910
>>>> do_syscall_64+0x1b9/0x820 arch/x86/entry/common.c:290
>>>> ==================================================================
>>>> BUG: KASAN: global-out-of-bounds in memcmp+0xe3/0x160 lib/string.c:861
>>>> Read of size 1 at addr ffffffff88000008 by task syz-executor0/10914
>>>>
>>>> entry_SYSCALL_64_after_hwframe+0x49/0xbe
>>>> RIP: 0033:0x457579
>>>> Code: 1d b4 fb ff c3 66 2e 0f 1f 84 00 00 00 00 00 66 90 48 89 f8 48 89 f7
>>>> 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff
>>>> 0f 83 eb b3 fb ff c3 66 2e 0f 1f 84 00 00 00 00
>>>> RSP: 002b:00007f4c14533c78 EFLAGS: 00000246 ORIG_RAX: 0000000000000036
>>>> RAX: ffffffffffffffda RBX: 00007f4c14533c90 RCX: 0000000000457579
>>>> RDX: 0000000000000040 RSI: 0000000000000000 RDI: 0000000000000003
>>>> RBP: 000000000072bf00 R08: 0000000000000004 R09: 0000000000000000
>>>> R10: 0000000020000080 R11: 0000000000000246 R12: 00007f4c145346d4
>>>> R13: 00000000004c3ed9 R14: 00000000004d6260 R15: 0000000000000004
>>>> CPU: 0 PID: 10914 Comm: syz-executor0 Not tainted 4.19.0-rc5+ #252
>>>> Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS
>>>> Google 01/01/2011
>>>> Call Trace:
>>>> __dump_stack lib/dump_stack.c:77 [inline]
>>>> dump_stack+0x1c4/0x2b4 lib/dump_stack.c:113
>>>> print_address_description.cold.8+0x58/0x1ff mm/kasan/report.c:256
>>>> kasan_report_error mm/kasan/report.c:354 [inline]
>>>> kasan_report.cold.9+0x242/0x309 mm/kasan/report.c:412
>>>> __asan_report_load1_noabort+0x14/0x20 mm/kasan/report.c:430
>>>> memcmp+0xe3/0x160 lib/string.c:861
>>>> strnstr+0x4b/0x70 lib/string.c:934
>>>> __aa_lookupn_ns+0xc1/0x570 security/apparmor/policy_ns.c:209
>>>> aa_lookupn_ns+0x88/0x1e0 security/apparmor/policy_ns.c:240
>>>> aa_fqlookupn_profile+0x1b9/0x1010 security/apparmor/policy.c:468
>>>> fqlookupn_profile+0x80/0xc0 security/apparmor/label.c:1844
>>>> aa_label_strn_parse+0xa3a/0x1230 security/apparmor/label.c:1908
>>>> aa_label_parse+0x42/0x50 security/apparmor/label.c:1943
>>>> aa_change_profile+0x513/0x3510 security/apparmor/domain.c:1362
>>>> apparmor_setprocattr+0xa8b/0x1150 security/apparmor/lsm.c:656
>>>> security_setprocattr+0x66/0xc0 security/security.c:1298
>>>> proc_pid_attr_write+0x301/0x540 fs/proc/base.c:2555
>>>> __vfs_write+0x119/0x9f0 fs/read_write.c:485
>>>> vfs_write+0x1fc/0x560 fs/read_write.c:549
>>>> ksys_write+0x101/0x260 fs/read_write.c:598
>>>> __do_sys_write fs/read_write.c:610 [inline]
>>>> __se_sys_write fs/read_write.c:607 [inline]
>>>> __x64_sys_write+0x73/0xb0 fs/read_write.c:607
>>>> do_syscall_64+0x1b9/0x820 arch/x86/entry/common.c:290
>>>> entry_SYSCALL_64_after_hwframe+0x49/0xbe
>>>> RIP: 0033:0x457579
>>>> Code: 1d b4 fb ff c3 66 2e 0f 1f 84 00 00 00 00 00 66 90 48 89 f8 48 89 f7
>>>> 48 89 d6 48 89 ca 4d 89 c2 4d 89 c8 4c 8b 4c 24 08 0f 05 <48> 3d 01 f0 ff ff
>>>> 0f 83 eb b3 fb ff c3 66 2e 0f 1f 84 00 00 00 00
>>>> RSP: 002b:00007f5a92ec2c78 EFLAGS: 00000246 ORIG_RAX: 0000000000000001
>>>> RAX: ffffffffffffffda RBX: 0000000000000003 RCX: 0000000000457579
>>>> RDX: 000000000000002c RSI: 00000000200000c0 RDI: 0000000000000004
>>>> RBP: 000000000072bf00 R08: 0000000000000000 R09: 0000000000000000
>>>> R10: 0000000000000000 R11: 0000000000000246 R12: 00007f5a92ec36d4
>>>> R13: 00000000004c5454 R14: 00000000004d8c78 R15: 00000000ffffffff
>>>>
>>>> CPU: 1 PID: 10921 Comm: syz-executor3 Not tainted 4.19.0-rc5+ #252
>>>> Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS
>>>> Google 01/01/2011
>>>> The buggy address belongs to the variable:
>>>> __start_rodata+0x8/0x1000
>>>> Call Trace:
>>>> __dump_stack lib/dump_stack.c:77 [inline]
>>>> dump_stack+0x1c4/0x2b4 lib/dump_stack.c:113
>>>>
>>>> Memory state around the buggy address:
>>>> ffffffff87ffff00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
>>>> ffffffff87ffff80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
>>>> fail_dump lib/fault-inject.c:51 [inline]
>>>> should_fail.cold.4+0xa/0x17 lib/fault-inject.c:149
>>>>>
>>>>> ffffffff88000000: 00 fa fa fa fa fa fa fa 00 01 fa fa fa fa fa fa
>>>>
>>>> ^
>>>> ffffffff88000080: 00 00 00 07 fa fa fa fa 00 04 fa fa fa fa fa fa
>>>> ffffffff88000100: 05 fa fa fa fa fa fa fa 00 00 00 00 05 fa fa fa
>>>> ==================================================================
>>>>
>>>>
>>>> ---
>>>> This bug is generated by a bot. It may contain errors.
>>>> See https://goo.gl/tpsmEJ for more information about syzbot.
>>>> syzbot engineers can be reached at syzkaller@googlegroups.com.
>>>>
>>>> syzbot will keep track of this bug report. See:
>>>> https://goo.gl/tpsmEJ#bug-status-tracking for how to communicate with
>>>> syzbot.
>
> --
> You received this message because you are subscribed to the Google Groups "syzkaller-bugs" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to syzkaller-bugs+unsubscribe@googlegroups.com.
> To view this discussion on the web visit https://groups.google.com/d/msgid/syzkaller-bugs/23948464-72d2-7d04-59b5-79606c24ed75%40canonical.com.
> For more options, visit https://groups.google.com/d/optout.
^ permalink raw reply
* INVESTMENT!
From: John Rees @ 2018-09-28 14:58 UTC (permalink / raw)
To: Recipients
I'm interested in funding your business project aimed at reaching an agreement.
^ permalink raw reply
* [PATCH v4 bpf-next 10/10] selftests/bpf: cgroup local storage-based network counters
From: Roman Gushchin @ 2018-09-28 14:46 UTC (permalink / raw)
To: netdev@vger.kernel.org
Cc: linux-kernel@vger.kernel.org, Kernel Team, Roman Gushchin,
Daniel Borkmann, Alexei Starovoitov
In-Reply-To: <20180928144452.5284-1-guro@fb.com>
This commit adds a bpf kselftest, which demonstrates how percpu
and shared cgroup local storage can be used for efficient lookup-free
network accounting.
Cgroup local storage provides generic memory area with a very efficient
lookup free access. To avoid expensive atomic operations for each
packet, per-cpu cgroup local storage is used. Each packet is initially
charged to a per-cpu counter, and only if the counter reaches certain
value (32 in this case), the charge is moved into the global atomic
counter. This allows to amortize atomic operations, keeping reasonable
accuracy.
The test also implements a naive network traffic throttling, mostly to
demonstrate the possibility of bpf cgroup--based network bandwidth
control.
Expected output:
./test_netcnt
test_netcnt:PASS
Signed-off-by: Roman Gushchin <guro@fb.com>
Acked-by: Song Liu <songliubraving@fb.com>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: Alexei Starovoitov <ast@kernel.org>
---
tools/testing/selftests/bpf/Makefile | 6 +-
tools/testing/selftests/bpf/netcnt_common.h | 24 +++
tools/testing/selftests/bpf/netcnt_prog.c | 71 +++++++++
tools/testing/selftests/bpf/test_netcnt.c | 158 ++++++++++++++++++++
4 files changed, 257 insertions(+), 2 deletions(-)
create mode 100644 tools/testing/selftests/bpf/netcnt_common.h
create mode 100644 tools/testing/selftests/bpf/netcnt_prog.c
create mode 100644 tools/testing/selftests/bpf/test_netcnt.c
diff --git a/tools/testing/selftests/bpf/Makefile b/tools/testing/selftests/bpf/Makefile
index 059d64a0f897..f802de526f57 100644
--- a/tools/testing/selftests/bpf/Makefile
+++ b/tools/testing/selftests/bpf/Makefile
@@ -23,7 +23,8 @@ $(TEST_CUSTOM_PROGS): $(OUTPUT)/%: %.c
TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \
test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \
test_sock test_btf test_sockmap test_lirc_mode2_user get_cgroup_id_user \
- test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names
+ test_socket_cookie test_cgroup_storage test_select_reuseport test_section_names \
+ test_netcnt
TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test_obj_id.o \
test_pkt_md_access.o test_xdp_redirect.o test_xdp_meta.o sockmap_parse_prog.o \
@@ -35,7 +36,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test
test_get_stack_rawtp.o test_sockmap_kern.o test_sockhash_kern.o \
test_lwt_seg6local.o sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o \
get_cgroup_id_kern.o socket_cookie_prog.o test_select_reuseport_kern.o \
- test_skb_cgroup_id_kern.o bpf_flow.o
+ test_skb_cgroup_id_kern.o bpf_flow.o netcnt_prog.o
# Order correspond to 'make run_tests' order
TEST_PROGS := test_kmod.sh \
@@ -72,6 +73,7 @@ $(OUTPUT)/test_tcpbpf_user: cgroup_helpers.c
$(OUTPUT)/test_progs: trace_helpers.c
$(OUTPUT)/get_cgroup_id_user: cgroup_helpers.c
$(OUTPUT)/test_cgroup_storage: cgroup_helpers.c
+$(OUTPUT)/test_netcnt: cgroup_helpers.c
.PHONY: force
diff --git a/tools/testing/selftests/bpf/netcnt_common.h b/tools/testing/selftests/bpf/netcnt_common.h
new file mode 100644
index 000000000000..81084c1c2c23
--- /dev/null
+++ b/tools/testing/selftests/bpf/netcnt_common.h
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0
+#ifndef __NETCNT_COMMON_H
+#define __NETCNT_COMMON_H
+
+#include <linux/types.h>
+
+#define MAX_PERCPU_PACKETS 32
+
+struct percpu_net_cnt {
+ __u64 packets;
+ __u64 bytes;
+
+ __u64 prev_ts;
+
+ __u64 prev_packets;
+ __u64 prev_bytes;
+};
+
+struct net_cnt {
+ __u64 packets;
+ __u64 bytes;
+};
+
+#endif
diff --git a/tools/testing/selftests/bpf/netcnt_prog.c b/tools/testing/selftests/bpf/netcnt_prog.c
new file mode 100644
index 000000000000..1198abca1360
--- /dev/null
+++ b/tools/testing/selftests/bpf/netcnt_prog.c
@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/bpf.h>
+#include <linux/version.h>
+
+#include "bpf_helpers.h"
+#include "netcnt_common.h"
+
+#define MAX_BPS (3 * 1024 * 1024)
+
+#define REFRESH_TIME_NS 100000000
+#define NS_PER_SEC 1000000000
+
+struct bpf_map_def SEC("maps") percpu_netcnt = {
+ .type = BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE,
+ .key_size = sizeof(struct bpf_cgroup_storage_key),
+ .value_size = sizeof(struct percpu_net_cnt),
+};
+
+struct bpf_map_def SEC("maps") netcnt = {
+ .type = BPF_MAP_TYPE_CGROUP_STORAGE,
+ .key_size = sizeof(struct bpf_cgroup_storage_key),
+ .value_size = sizeof(struct net_cnt),
+};
+
+SEC("cgroup/skb")
+int bpf_nextcnt(struct __sk_buff *skb)
+{
+ struct percpu_net_cnt *percpu_cnt;
+ char fmt[] = "%d %llu %llu\n";
+ struct net_cnt *cnt;
+ __u64 ts, dt;
+ int ret;
+
+ cnt = bpf_get_local_storage(&netcnt, 0);
+ percpu_cnt = bpf_get_local_storage(&percpu_netcnt, 0);
+
+ percpu_cnt->packets++;
+ percpu_cnt->bytes += skb->len;
+
+ if (percpu_cnt->packets > MAX_PERCPU_PACKETS) {
+ __sync_fetch_and_add(&cnt->packets,
+ percpu_cnt->packets);
+ percpu_cnt->packets = 0;
+
+ __sync_fetch_and_add(&cnt->bytes,
+ percpu_cnt->bytes);
+ percpu_cnt->bytes = 0;
+ }
+
+ ts = bpf_ktime_get_ns();
+ dt = ts - percpu_cnt->prev_ts;
+
+ dt *= MAX_BPS;
+ dt /= NS_PER_SEC;
+
+ if (cnt->bytes + percpu_cnt->bytes - percpu_cnt->prev_bytes < dt)
+ ret = 1;
+ else
+ ret = 0;
+
+ if (dt > REFRESH_TIME_NS) {
+ percpu_cnt->prev_ts = ts;
+ percpu_cnt->prev_packets = cnt->packets;
+ percpu_cnt->prev_bytes = cnt->bytes;
+ }
+
+ return !!ret;
+}
+
+char _license[] SEC("license") = "GPL";
+__u32 _version SEC("version") = LINUX_VERSION_CODE;
diff --git a/tools/testing/selftests/bpf/test_netcnt.c b/tools/testing/selftests/bpf/test_netcnt.c
new file mode 100644
index 000000000000..7887df693399
--- /dev/null
+++ b/tools/testing/selftests/bpf/test_netcnt.c
@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/sysinfo.h>
+#include <sys/time.h>
+
+#include <linux/bpf.h>
+#include <bpf/bpf.h>
+#include <bpf/libbpf.h>
+
+#include "cgroup_helpers.h"
+#include "bpf_rlimit.h"
+#include "netcnt_common.h"
+
+#define BPF_PROG "./netcnt_prog.o"
+#define TEST_CGROUP "/test-network-counters/"
+
+static int bpf_find_map(const char *test, struct bpf_object *obj,
+ const char *name)
+{
+ struct bpf_map *map;
+
+ map = bpf_object__find_map_by_name(obj, name);
+ if (!map) {
+ printf("%s:FAIL:map '%s' not found\n", test, name);
+ return -1;
+ }
+ return bpf_map__fd(map);
+}
+
+int main(int argc, char **argv)
+{
+ struct percpu_net_cnt *percpu_netcnt;
+ struct bpf_cgroup_storage_key key;
+ int map_fd, percpu_map_fd;
+ int error = EXIT_FAILURE;
+ struct net_cnt netcnt;
+ struct bpf_object *obj;
+ int prog_fd, cgroup_fd;
+ unsigned long packets;
+ unsigned long bytes;
+ int cpu, nproc;
+ __u32 prog_cnt;
+
+ nproc = get_nprocs_conf();
+ percpu_netcnt = malloc(sizeof(*percpu_netcnt) * nproc);
+ if (!percpu_netcnt) {
+ printf("Not enough memory for per-cpu area (%d cpus)\n", nproc);
+ goto err;
+ }
+
+ if (bpf_prog_load(BPF_PROG, BPF_PROG_TYPE_CGROUP_SKB,
+ &obj, &prog_fd)) {
+ printf("Failed to load bpf program\n");
+ goto out;
+ }
+
+ if (setup_cgroup_environment()) {
+ printf("Failed to load bpf program\n");
+ goto err;
+ }
+
+ /* Create a cgroup, get fd, and join it */
+ cgroup_fd = create_and_get_cgroup(TEST_CGROUP);
+ if (!cgroup_fd) {
+ printf("Failed to create test cgroup\n");
+ goto err;
+ }
+
+ if (join_cgroup(TEST_CGROUP)) {
+ printf("Failed to join cgroup\n");
+ goto err;
+ }
+
+ /* Attach bpf program */
+ if (bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_INET_EGRESS, 0)) {
+ printf("Failed to attach bpf program");
+ goto err;
+ }
+
+ assert(system("ping localhost -6 -c 10000 -f -q > /dev/null") == 0);
+
+ if (bpf_prog_query(cgroup_fd, BPF_CGROUP_INET_EGRESS, 0, NULL, NULL,
+ &prog_cnt)) {
+ printf("Failed to query attached programs");
+ goto err;
+ }
+
+ map_fd = bpf_find_map(__func__, obj, "netcnt");
+ if (map_fd < 0) {
+ printf("Failed to find bpf map with net counters");
+ goto err;
+ }
+
+ percpu_map_fd = bpf_find_map(__func__, obj, "percpu_netcnt");
+ if (percpu_map_fd < 0) {
+ printf("Failed to find bpf map with percpu net counters");
+ goto err;
+ }
+
+ if (bpf_map_get_next_key(map_fd, NULL, &key)) {
+ printf("Failed to get key in cgroup storage\n");
+ goto err;
+ }
+
+ if (bpf_map_lookup_elem(map_fd, &key, &netcnt)) {
+ printf("Failed to lookup cgroup storage\n");
+ goto err;
+ }
+
+ if (bpf_map_lookup_elem(percpu_map_fd, &key, &percpu_netcnt[0])) {
+ printf("Failed to lookup percpu cgroup storage\n");
+ goto err;
+ }
+
+ /* Some packets can be still in per-cpu cache, but not more than
+ * MAX_PERCPU_PACKETS.
+ */
+ packets = netcnt.packets;
+ bytes = netcnt.bytes;
+ for (cpu = 0; cpu < nproc; cpu++) {
+ if (percpu_netcnt[cpu].packets > MAX_PERCPU_PACKETS) {
+ printf("Unexpected percpu value: %llu\n",
+ percpu_netcnt[cpu].packets);
+ goto err;
+ }
+
+ packets += percpu_netcnt[cpu].packets;
+ bytes += percpu_netcnt[cpu].bytes;
+ }
+
+ /* No packets should be lost */
+ if (packets != 10000) {
+ printf("Unexpected packet count: %lu\n", packets);
+ goto err;
+ }
+
+ /* Let's check that bytes counter matches the number of packets
+ * multiplied by the size of ipv6 ICMP packet.
+ */
+ if (bytes != packets * 104) {
+ printf("Unexpected bytes count: %lu\n", bytes);
+ goto err;
+ }
+
+ error = 0;
+ printf("test_netcnt:PASS\n");
+
+err:
+ cleanup_cgroup_environment();
+ free(percpu_netcnt);
+
+out:
+ return error;
+}
--
2.17.1
^ permalink raw reply related
* [PATCH iproute2-next] tc: f_flower: add geneve option match support to flower
From: Simon Horman @ 2018-09-28 14:03 UTC (permalink / raw)
To: David Ahern
Cc: Jiri Pirko, Jamal Hadi Salim, Cong Wang, netdev, oss-drivers,
Pieter Jansen van Vuuren, Simon Horman
From: Pieter Jansen van Vuuren <pieter.jansenvanvuuren@netronome.com>
Allow matching on options in Geneve tunnel headers.
The options can be described in the form
CLASS:TYPE:DATA/CLASS_MASK:TYPE_MASK:DATA_MASK, where CLASS is
represented as a 16bit hexadecimal value, TYPE as an 8bit
hexadecimal value and DATA as a variable length hexadecimal value.
e.g.
# ip link add name geneve0 type geneve dstport 0 external
# tc qdisc add dev geneve0 ingress
# tc filter add dev geneve0 protocol ip parent ffff: \
flower \
enc_src_ip 10.0.99.192 \
enc_dst_ip 10.0.99.193 \
enc_key_id 11 \
geneve_opts 0102:80:1122334421314151/ffff:ff:ffffffffffffffff \
ip_proto udp \
action mirred egress redirect dev eth1
Signed-off-by: Pieter Jansen van Vuuren <pieter.jansenvanvuuren@netronome.com>
Signed-off-by: Simon Horman <simon.horman@netronome.com>
---
man/man8/tc-flower.8 | 13 ++-
tc/f_flower.c | 282 +++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 294 insertions(+), 1 deletion(-)
diff --git a/man/man8/tc-flower.8 b/man/man8/tc-flower.8
index 305d7efe046a..8be8882592ea 100644
--- a/man/man8/tc-flower.8
+++ b/man/man8/tc-flower.8
@@ -80,6 +80,8 @@ flower \- flow based traffic control filter
.IR TOS " | "
.B enc_ttl
.IR TTL " | "
+.B geneve_opts
+.IR OPTIONS " | "
.BR ip_flags
.IR IP_FLAGS
.SH DESCRIPTION
@@ -283,6 +285,8 @@ bits is assumed.
.BI enc_tos " NUMBER"
.TQ
.BI enc_ttl " NUMBER"
+.TQ
+.BI geneve_opts " OPTIONS"
Match on IP tunnel metadata. Key id
.I NUMBER
is a 32 bit tunnel key id (e.g. VNI for VXLAN tunnel).
@@ -295,7 +299,14 @@ is a 16 bit UDP dst port. Tos
.I NUMBER
is an 8 bit tos (dscp+ecn) value, ttl
.I NUMBER
-is an 8 bit time-to-live value.
+is an 8 bit time-to-live value. geneve_opts
+.I OPTIONS
+must be a valid list of comma-separated geneve options where each option
+consists of a key optionally followed by a slash and corresponding mask. If
+the masks is missing, \fBtc\fR assumes a full-length match. The options can
+be described in the form CLASS:TYPE:DATA/CLASS_MASK:TYPE_MASK:DATA_MASK,
+where CLASS is represented as a 16bit hexadecimal value, TYPE as an 8bit
+hexadecimal value and DATA as a variable length hexadecimal value.
.TP
.BI ip_flags " IP_FLAGS"
.I IP_FLAGS
diff --git a/tc/f_flower.c b/tc/f_flower.c
index 59e5f572c542..4a8fb984a35a 100644
--- a/tc/f_flower.c
+++ b/tc/f_flower.c
@@ -79,6 +79,7 @@ static void explain(void)
" enc_key_id [ KEY-ID ] |\n"
" enc_tos MASKED-IP_TOS |\n"
" enc_ttl MASKED-IP_TTL |\n"
+ " geneve_opts MASKED-OPTIONS |\n"
" ip_flags IP-FLAGS | \n"
" enc_dst_port [ port_number ] }\n"
" FILTERID := X:Y:Z\n"
@@ -589,6 +590,179 @@ static int flower_parse_enc_port(char *str, int type, struct nlmsghdr *n)
return 0;
}
+static int flower_parse_geneve_opts(char *str, struct nlmsghdr *n)
+{
+ struct rtattr *nest;
+ char *token;
+ int i, err;
+
+ nest = addattr_nest(n, MAX_MSG, TCA_FLOWER_KEY_ENC_OPTS_GENEVE);
+
+ i = 1;
+ token = strsep(&str, ":");
+ while (token) {
+ switch (i) {
+ case TCA_FLOWER_KEY_ENC_OPT_GENEVE_CLASS:
+ {
+ __be16 opt_class;
+
+ if (!strlen(token))
+ break;
+ err = get_be16(&opt_class, token, 16);
+ if (err)
+ return err;
+
+ addattr16(n, MAX_MSG, i, opt_class);
+ break;
+ }
+ case TCA_FLOWER_KEY_ENC_OPT_GENEVE_TYPE:
+ {
+ __u8 opt_type;
+
+ if (!strlen(token))
+ break;
+ err = get_u8(&opt_type, token, 16);
+ if (err)
+ return err;
+
+ addattr8(n, MAX_MSG, i, opt_type);
+ break;
+ }
+ case TCA_FLOWER_KEY_ENC_OPT_GENEVE_DATA:
+ {
+ size_t token_len = strlen(token);
+ __u8 *opts;
+
+ if (!token_len)
+ break;
+ opts = malloc(token_len / 2);
+ if (!opts)
+ return -1;
+ if (hex2mem(token, opts, token_len / 2) < 0) {
+ free(opts);
+ return -1;
+ }
+ addattr_l(n, MAX_MSG, i, opts, token_len / 2);
+ free(opts);
+
+ break;
+ }
+ default:
+ fprintf(stderr, "Unknown \"geneve_opts\" type\n");
+ return -1;
+ }
+
+ token = strsep(&str, ":");
+ i++;
+ }
+ addattr_nest_end(n, nest);
+
+ return 0;
+}
+
+static int flower_parse_enc_opt_part(char *str, struct nlmsghdr *n)
+{
+ char *token;
+ int err;
+
+ token = strsep(&str, ",");
+ while (token) {
+ err = flower_parse_geneve_opts(token, n);
+ if (err)
+ return err;
+
+ token = strsep(&str, ",");
+ }
+
+ return 0;
+}
+
+static int flower_check_enc_opt_key(char *key)
+{
+ int key_len, col_cnt = 0;
+
+ key_len = strlen(key);
+ while ((key = strchr(key, ':'))) {
+ if (strlen(key) == key_len)
+ return -1;
+
+ key_len = strlen(key) - 1;
+ col_cnt++;
+ key++;
+ }
+
+ if (col_cnt != 2 || !key_len)
+ return -1;
+
+ return 0;
+}
+
+static int flower_parse_enc_opts(char *str, struct nlmsghdr *n)
+{
+ char key[XATTR_SIZE_MAX], mask[XATTR_SIZE_MAX];
+ int data_len, key_len, mask_len, err;
+ char *token, *slash;
+ struct rtattr *nest;
+
+ key_len = 0;
+ mask_len = 0;
+ token = strsep(&str, ",");
+ while (token) {
+ slash = strchr(token, '/');
+ if (slash)
+ *slash = '\0';
+
+ if ((key_len + strlen(token) > XATTR_SIZE_MAX) ||
+ flower_check_enc_opt_key(token))
+ return -1;
+
+ strcpy(&key[key_len], token);
+ key_len += strlen(token) + 1;
+ key[key_len - 1] = ',';
+
+ if (!slash) {
+ /* Pad out mask when not provided */
+ if (mask_len + strlen(token) > XATTR_SIZE_MAX)
+ return -1;
+
+ data_len = strlen(rindex(token, ':'));
+ sprintf(&mask[mask_len], "ffff:ff:");
+ mask_len += 8;
+ memset(&mask[mask_len], 'f', data_len - 1);
+ mask_len += data_len;
+ mask[mask_len - 1] = ',';
+ token = strsep(&str, ",");
+ continue;
+ }
+
+ if (mask_len + strlen(slash + 1) > XATTR_SIZE_MAX)
+ return -1;
+
+ strcpy(&mask[mask_len], slash + 1);
+ mask_len += strlen(slash + 1) + 1;
+ mask[mask_len - 1] = ',';
+
+ *slash = '/';
+ token = strsep(&str, ",");
+ }
+ key[key_len - 1] = '\0';
+ mask[mask_len - 1] = '\0';
+
+ nest = addattr_nest(n, MAX_MSG, TCA_FLOWER_KEY_ENC_OPTS);
+ err = flower_parse_enc_opt_part(key, n);
+ if (err)
+ return err;
+ addattr_nest_end(n, nest);
+
+ nest = addattr_nest(n, MAX_MSG, TCA_FLOWER_KEY_ENC_OPTS_MASK);
+ err = flower_parse_enc_opt_part(mask, n);
+ if (err)
+ return err;
+ addattr_nest_end(n, nest);
+
+ return 0;
+}
+
static int flower_parse_opt(struct filter_util *qu, char *handle,
int argc, char **argv, struct nlmsghdr *n)
{
@@ -1041,6 +1215,13 @@ static int flower_parse_opt(struct filter_util *qu, char *handle,
fprintf(stderr, "Illegal \"enc_ttl\"\n");
return -1;
}
+ } else if (matches(*argv, "geneve_opts") == 0) {
+ NEXT_ARG();
+ ret = flower_parse_enc_opts(*argv, n);
+ if (ret < 0) {
+ fprintf(stderr, "Illegal \"geneve_opts\"\n");
+ return -1;
+ }
} else if (matches(*argv, "action") == 0) {
NEXT_ARG();
ret = parse_action(&argc, &argv, TCA_FLOWER_ACT, n);
@@ -1340,6 +1521,105 @@ static void flower_print_key_id(const char *name, struct rtattr *attr)
print_uint(PRINT_ANY, name, namefrm, rta_getattr_be32(attr));
}
+static void flower_print_geneve_opts(const char *name, struct rtattr *attr,
+ char *strbuf)
+{
+ struct rtattr *tb[TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX + 1];
+ int ii, data_len, offset = 0, slen = 0;
+ struct rtattr *i = RTA_DATA(attr);
+ int rem = RTA_PAYLOAD(attr);
+ __u8 type, data_r[rem];
+ char data[rem * 2 + 1];
+ __u16 class;
+
+ open_json_array(PRINT_JSON, name);
+ while (rem) {
+ parse_rtattr(tb, TCA_FLOWER_KEY_ENC_OPT_GENEVE_MAX, i, rem);
+ class = rta_getattr_be16(tb[TCA_FLOWER_KEY_ENC_OPT_GENEVE_CLASS]);
+ type = rta_getattr_u8(tb[TCA_FLOWER_KEY_ENC_OPT_GENEVE_TYPE]);
+ data_len = RTA_PAYLOAD(tb[TCA_FLOWER_KEY_ENC_OPT_GENEVE_DATA]);
+ hexstring_n2a(RTA_DATA(tb[TCA_FLOWER_KEY_ENC_OPT_GENEVE_DATA]),
+ data_len, data, sizeof(data));
+ hex2mem(data, data_r, data_len);
+ offset += data_len + 20;
+ rem -= data_len + 20;
+ i = RTA_DATA(attr) + offset;
+
+ open_json_object(NULL);
+ print_uint(PRINT_JSON, "class", NULL, class);
+ print_uint(PRINT_JSON, "type", NULL, type);
+ open_json_array(PRINT_JSON, "data");
+ for (ii = 0; ii < data_len; ii++)
+ print_uint(PRINT_JSON, NULL, NULL, data_r[ii]);
+ close_json_array(PRINT_JSON, "data");
+ close_json_object();
+
+ slen += sprintf(strbuf + slen, "%04x:%02x:%s",
+ class, type, data);
+ if (rem)
+ slen += sprintf(strbuf + slen, ",");
+ }
+ close_json_array(PRINT_JSON, name);
+}
+
+static void flower_print_geneve_parts(const char *name, struct rtattr *attr,
+ char *key, char *mask)
+{
+ char *namefrm = "\n geneve_opt %s";
+ char *key_token, *mask_token, *out;
+ int len;
+
+ out = malloc(RTA_PAYLOAD(attr) * 4 + 3);
+ if (!out)
+ return;
+
+ len = 0;
+ key_token = strsep(&key, ",");
+ mask_token = strsep(&mask, ",");
+ while (key_token) {
+ len += sprintf(&out[len], "%s/%s,", key_token, mask_token);
+ mask_token = strsep(&mask, ",");
+ key_token = strsep(&key, ",");
+ }
+
+ out[len - 1] = '\0';
+ print_string(PRINT_FP, name, namefrm, out);
+ free(out);
+}
+
+static void flower_print_enc_opts(const char *name, struct rtattr *attr,
+ struct rtattr *mask_attr)
+{
+ struct rtattr *key_tb[TCA_FLOWER_KEY_ENC_OPTS_MAX + 1];
+ struct rtattr *msk_tb[TCA_FLOWER_KEY_ENC_OPTS_MAX + 1];
+ char *key, *msk;
+
+ if (!attr)
+ return;
+
+ key = malloc(RTA_PAYLOAD(attr) * 2 + 1);
+ if (!key)
+ return;
+
+ msk = malloc(RTA_PAYLOAD(attr) * 2 + 1);
+ if (!msk)
+ goto err_key_free;
+
+ parse_rtattr_nested(key_tb, TCA_FLOWER_KEY_ENC_OPTS_MAX, attr);
+ flower_print_geneve_opts("geneve_opt_key",
+ key_tb[TCA_FLOWER_KEY_ENC_OPTS_GENEVE], key);
+
+ parse_rtattr_nested(msk_tb, TCA_FLOWER_KEY_ENC_OPTS_MAX, mask_attr);
+ flower_print_geneve_opts("geneve_opt_mask",
+ msk_tb[TCA_FLOWER_KEY_ENC_OPTS_GENEVE], msk);
+
+ flower_print_geneve_parts(name, attr, key, msk);
+
+ free(msk);
+err_key_free:
+ free(key);
+}
+
static void flower_print_masked_u8(const char *name, struct rtattr *attr,
struct rtattr *mask_attr,
const char *(*value_to_str)(__u8 value))
@@ -1570,6 +1850,8 @@ static int flower_print_opt(struct filter_util *qu, FILE *f,
tb[TCA_FLOWER_KEY_ENC_IP_TOS_MASK]);
flower_print_ip_attr("enc_ttl", tb[TCA_FLOWER_KEY_ENC_IP_TTL],
tb[TCA_FLOWER_KEY_ENC_IP_TTL_MASK]);
+ flower_print_enc_opts("enc_opt", tb[TCA_FLOWER_KEY_ENC_OPTS],
+ tb[TCA_FLOWER_KEY_ENC_OPTS_MASK]);
flower_print_matching_flags("ip_flags", FLOWER_IP_FLAGS,
tb[TCA_FLOWER_KEY_FLAGS],
--
2.11.0
^ permalink raw reply related
* Re: [PATCHv3 bpf-next 01/12] bpf: Add iterator for spilled registers
From: Daniel Borkmann @ 2018-09-28 13:41 UTC (permalink / raw)
To: Joe Stringer
Cc: netdev, ast, john.fastabend, tgraf, kafai, nitin.hande,
mauricio.vasquez
In-Reply-To: <20180927232659.14348-2-joe@wand.net.nz>
On 09/28/2018 01:26 AM, Joe Stringer wrote:
> Add this iterator for spilled registers, it concentrates the details of
> how to get the current frame's spilled registers into a single macro
> while clarifying the intention of the code which is calling the macro.
>
> Signed-off-by: Joe Stringer <joe@wand.net.nz>
> Acked-by: Alexei Starovoitov <ast@kernel.org>
> ---
> include/linux/bpf_verifier.h | 11 +++++++++++
> kernel/bpf/verifier.c | 16 +++++++---------
> 2 files changed, 18 insertions(+), 9 deletions(-)
>
> diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
> index b42b60a83e19..af262b97f586 100644
> --- a/include/linux/bpf_verifier.h
> +++ b/include/linux/bpf_verifier.h
> @@ -131,6 +131,17 @@ struct bpf_verifier_state {
> u32 curframe;
> };
>
> +#define __get_spilled_reg(slot, frame) \
> + (((slot < frame->allocated_stack / BPF_REG_SIZE) && \
> + (frame->stack[slot].slot_type[0] == STACK_SPILL)) \
> + ? &frame->stack[slot].spilled_ptr : NULL)
> +
> +/* Iterate over 'frame', setting 'reg' to either NULL or a spilled register. */
> +#define for_each_spilled_reg(iter, frame, reg) \
> + for (iter = 0, reg = __get_spilled_reg(iter, frame); \
> + iter < frame->allocated_stack / BPF_REG_SIZE; \
> + iter++, reg = __get_spilled_reg(iter, frame))
> +
(Just a very small nit: please make sure this has a bpf_ prefix given this
is a global kernel header.)
^ permalink raw reply
* Re: [PATCHv3 bpf-next 04/12] bpf: Add PTR_TO_SOCKET verifier type
From: Daniel Borkmann @ 2018-09-28 13:38 UTC (permalink / raw)
To: Joe Stringer
Cc: netdev, ast, john.fastabend, tgraf, kafai, nitin.hande,
mauricio.vasquez
In-Reply-To: <20180927232659.14348-5-joe@wand.net.nz>
On 09/28/2018 01:26 AM, Joe Stringer wrote:
> Teach the verifier a little bit about a new type of pointer, a
> PTR_TO_SOCKET. This pointer type is accessed from BPF through the
> 'struct bpf_sock' structure.
>
> Signed-off-by: Joe Stringer <joe@wand.net.nz>
[...]
> +/* Return true if it's OK to have the same insn return a different type. */
> +static bool reg_type_mismatch_ok(enum bpf_reg_type type)
> +{
> + switch (type) {
> + case PTR_TO_CTX:
> + case PTR_TO_SOCKET:
> + case PTR_TO_SOCKET_OR_NULL:
> + return false;
> + default:
> + return true;
> + }
> +}
> +
> +/* If an instruction was previously used with particular pointer types, then we
> + * need to be careful to avoid cases such as the below, where it may be ok
> + * for one branch accessing the pointer, but not ok for the other branch:
> + *
> + * R1 = sock_ptr
> + * goto X;
> + * ...
> + * R1 = some_other_valid_ptr;
> + * goto X;
> + * ...
> + * R2 = *(u32 *)(R1 + 0);
> + */
> +static bool reg_type_mismatch(enum bpf_reg_type src, enum bpf_reg_type prev)
> +{
> + return src != prev && (!reg_type_mismatch_ok(src) ||
> + !reg_type_mismatch_ok(prev));
> +}
> +
> static int do_check(struct bpf_verifier_env *env)
> {
> struct bpf_verifier_state *state;
> @@ -4812,9 +4894,7 @@ static int do_check(struct bpf_verifier_env *env)
> */
> *prev_src_type = src_reg_type;
>
> - } else if (src_reg_type != *prev_src_type &&
> - (src_reg_type == PTR_TO_CTX ||
> - *prev_src_type == PTR_TO_CTX)) {
> + } else if (reg_type_mismatch(src_reg_type, *prev_src_type)) {
> /* ABuser program is trying to use the same insn
> * dst_reg = *(u32*) (src_reg + off)
> * with different pointer types:
> @@ -4859,9 +4939,7 @@ static int do_check(struct bpf_verifier_env *env)
>
> if (*prev_dst_type == NOT_INIT) {
> *prev_dst_type = dst_reg_type;
> - } else if (dst_reg_type != *prev_dst_type &&
> - (dst_reg_type == PTR_TO_CTX ||
> - *prev_dst_type == PTR_TO_CTX)) {
> + } else if (reg_type_mismatch(dst_reg_type, *prev_dst_type)) {
> verbose(env, "same insn cannot be used with different pointers\n");
> return -EINVAL;
Can also be as follow-up later on, but it would be crucial to also have
test_verifier tests on this logic here with mixing these pointer types
from different branches (right now we only cover ctx there).
Thanks,
Daniel
^ permalink raw reply
* Re: [RFC PATCH v2 bpf-next 0/2] verifier liveness simplification
From: Edward Cree @ 2018-09-28 13:36 UTC (permalink / raw)
To: Jiong Wang, ast, daniel; +Cc: netdev
In-Reply-To: <0252cca7-82e4-24d3-8682-e1a613d6cd78@netronome.com>
On 26/09/18 23:16, Jiong Wang wrote:
> On 22/08/2018 20:00, Edward Cree wrote:
>> In the future this idea may be extended to form use-def chains.
>
> 1. instruction level use->def chain
>
> - new use->def chains for each instruction. one eBPF insn could have two
> uses at maximum.
I was thinking of something a lot weaker/simpler, just making
ld rX, rY
copy rY.parent into rX.parent and not read-mark rY (whereas actual
arithmetic, pointer deref etc. would still create read marks).
But what you've described sounds interesting; perhaps it would also
help later with loop-variable handling?
-Ed
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox