1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright 2019 Google LLC
4 */
5
6 #include <errno.h>
7 #include <stdlib.h>
8
9 #define TST_NO_DEFAULT_MAIN
10 #include "tst_test.h"
11 #include "tst_af_alg.h"
12 #include "lapi/socket.h"
13
tst_alg_create(void)14 int tst_alg_create(void)
15 {
16 TEST(socket(AF_ALG, SOCK_SEQPACKET, 0));
17 if (TST_RET >= 0)
18 return TST_RET;
19 if (TST_ERR == EAFNOSUPPORT)
20 tst_brk(TCONF, "kernel doesn't support AF_ALG");
21 tst_brk(TBROK | TTERRNO, "unexpected error creating AF_ALG socket");
22 return -1;
23 }
24
tst_alg_bind_addr(int algfd,const struct sockaddr_alg * addr)25 void tst_alg_bind_addr(int algfd, const struct sockaddr_alg *addr)
26 {
27 TEST(bind(algfd, (const struct sockaddr *)addr, sizeof(*addr)));
28 if (TST_RET == 0)
29 return;
30 if (TST_ERR == ENOENT) {
31 tst_brk(TCONF, "kernel doesn't support %s algorithm '%s'",
32 addr->salg_type, addr->salg_name);
33 }
34 tst_brk(TBROK | TTERRNO,
35 "unexpected error binding AF_ALG socket to %s algorithm '%s'",
36 addr->salg_type, addr->salg_name);
37 }
38
init_sockaddr_alg(struct sockaddr_alg * addr,const char * algtype,const char * algname)39 static void init_sockaddr_alg(struct sockaddr_alg *addr,
40 const char *algtype, const char *algname)
41 {
42 memset(addr, 0, sizeof(*addr));
43
44 addr->salg_family = AF_ALG;
45
46 strncpy((char *)addr->salg_type, algtype, sizeof(addr->salg_type));
47 if (addr->salg_type[sizeof(addr->salg_type) - 1] != '\0')
48 tst_brk(TBROK, "algorithm type too long: '%s'", algtype);
49
50 strncpy((char *)addr->salg_name, algname, sizeof(addr->salg_name));
51 if (addr->salg_name[sizeof(addr->salg_name) - 1] != '\0')
52 tst_brk(TBROK, "algorithm name too long: '%s'", algname);
53 }
54
tst_alg_bind(int algfd,const char * algtype,const char * algname)55 void tst_alg_bind(int algfd, const char *algtype, const char *algname)
56 {
57 struct sockaddr_alg addr;
58
59 init_sockaddr_alg(&addr, algtype, algname);
60
61 tst_alg_bind_addr(algfd, &addr);
62 }
63
tst_have_alg(const char * algtype,const char * algname)64 bool tst_have_alg(const char *algtype, const char *algname)
65 {
66 int algfd;
67 struct sockaddr_alg addr;
68 bool have_alg = true;
69
70 algfd = tst_alg_create();
71
72 init_sockaddr_alg(&addr, algtype, algname);
73
74 TEST(bind(algfd, (const struct sockaddr *)&addr, sizeof(addr)));
75 if (TST_RET != 0) {
76 if (TST_ERR != ENOENT) {
77 tst_brk(TBROK | TTERRNO,
78 "unexpected error binding AF_ALG socket to %s algorithm '%s'",
79 algtype, algname);
80 }
81 have_alg = false;
82 }
83
84 close(algfd);
85 return have_alg;
86 }
87
tst_require_alg(const char * algtype,const char * algname)88 void tst_require_alg(const char *algtype, const char *algname)
89 {
90 int algfd = tst_alg_create();
91
92 tst_alg_bind(algfd, algtype, algname);
93
94 close(algfd);
95 }
96
tst_alg_setkey(int algfd,const uint8_t * key,unsigned int keylen)97 void tst_alg_setkey(int algfd, const uint8_t *key, unsigned int keylen)
98 {
99 uint8_t *keybuf = NULL;
100 unsigned int i;
101
102 if (key == NULL) {
103 /* generate a random key */
104 keybuf = SAFE_MALLOC(keylen);
105 for (i = 0; i < keylen; i++)
106 keybuf[i] = rand();
107 key = keybuf;
108 }
109 TEST(setsockopt(algfd, SOL_ALG, ALG_SET_KEY, key, keylen));
110 if (TST_RET != 0) {
111 tst_brk(TBROK | TTERRNO,
112 "unexpected error setting key (len=%u)", keylen);
113 }
114 free(keybuf);
115 }
116
tst_alg_accept(int algfd)117 int tst_alg_accept(int algfd)
118 {
119 TEST(accept(algfd, NULL, NULL));
120 if (TST_RET < 0) {
121 tst_brk(TBROK | TTERRNO,
122 "unexpected error accept()ing AF_ALG request socket");
123 }
124 return TST_RET;
125 }
126
tst_alg_setup(const char * algtype,const char * algname,const uint8_t * key,unsigned int keylen)127 int tst_alg_setup(const char *algtype, const char *algname,
128 const uint8_t *key, unsigned int keylen)
129 {
130 int algfd = tst_alg_create();
131
132 tst_alg_bind(algfd, algtype, algname);
133
134 if (keylen != 0)
135 tst_alg_setkey(algfd, key, keylen);
136
137 return algfd;
138 }
139
tst_alg_setup_reqfd(const char * algtype,const char * algname,const uint8_t * key,unsigned int keylen)140 int tst_alg_setup_reqfd(const char *algtype, const char *algname,
141 const uint8_t *key, unsigned int keylen)
142 {
143 int algfd = tst_alg_setup(algtype, algname, key, keylen);
144 int reqfd = tst_alg_accept(algfd);
145
146 close(algfd);
147 return reqfd;
148 }
149
tst_alg_sendmsg(int reqfd,const void * data,size_t datalen,const struct tst_alg_sendmsg_params * params)150 void tst_alg_sendmsg(int reqfd, const void *data, size_t datalen,
151 const struct tst_alg_sendmsg_params *params)
152 {
153 struct iovec iov = {
154 .iov_base = (void *)data,
155 .iov_len = datalen,
156 };
157 struct msghdr msg = {
158 .msg_iov = &iov,
159 .msg_iovlen = 1,
160 .msg_flags = params->msg_flags,
161 };
162 size_t controllen;
163 uint8_t *control;
164 struct cmsghdr *cmsg;
165 struct af_alg_iv *alg_iv;
166
167 if (params->encrypt && params->decrypt)
168 tst_brk(TBROK, "Both encrypt and decrypt are specified");
169
170 controllen = 0;
171 if (params->encrypt || params->decrypt)
172 controllen += CMSG_SPACE(sizeof(uint32_t));
173 if (params->ivlen)
174 controllen += CMSG_SPACE(sizeof(struct af_alg_iv) +
175 params->ivlen);
176 if (params->assoclen)
177 controllen += CMSG_SPACE(sizeof(uint32_t));
178
179 control = SAFE_MALLOC(controllen);
180 memset(control, 0, controllen);
181 msg.msg_control = control;
182 msg.msg_controllen = controllen;
183 cmsg = CMSG_FIRSTHDR(&msg);
184
185 if (params->encrypt || params->decrypt) {
186 cmsg->cmsg_level = SOL_ALG;
187 cmsg->cmsg_type = ALG_SET_OP;
188 cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
189 *(uint32_t *)CMSG_DATA(cmsg) =
190 params->encrypt ? ALG_OP_ENCRYPT : ALG_OP_DECRYPT;
191 cmsg = CMSG_NXTHDR(&msg, cmsg);
192 }
193 if (params->ivlen) {
194 cmsg->cmsg_level = SOL_ALG;
195 cmsg->cmsg_type = ALG_SET_IV;
196 cmsg->cmsg_len = CMSG_LEN(sizeof(struct af_alg_iv) +
197 params->ivlen);
198 alg_iv = (struct af_alg_iv *)CMSG_DATA(cmsg);
199 alg_iv->ivlen = params->ivlen;
200 memcpy(alg_iv->iv, params->iv, params->ivlen);
201 cmsg = CMSG_NXTHDR(&msg, cmsg);
202 }
203 if (params->assoclen) {
204 cmsg->cmsg_level = SOL_ALG;
205 cmsg->cmsg_type = ALG_SET_AEAD_ASSOCLEN;
206 cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
207 *(uint32_t *)CMSG_DATA(cmsg) = params->assoclen;
208 cmsg = CMSG_NXTHDR(&msg, cmsg);
209 }
210
211 SAFE_SENDMSG(datalen, reqfd, &msg, 0);
212 }
213