www.gitorious.org Git - gnutls:gnutls.git/blob

1 /*

3 *

4 * Author: Nikos Mavrogiannopoulos

5 *

6 * This file is part of GnuTLS.

7 *

8 * GnuTLS is free software; you can redistribute it and/or modify it

9 * under the terms of the GNU General Public License as published by

10 * the Free Software Foundation; either version 3 of the License, or

11 * (at your option) any later version.

12 *

13 * GnuTLS is distributed in the hope that it will be useful, but

14 * WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * General Public License for more details.

17 *

18 * You should have received a copy of the GNU General Public License

19 * along with GnuTLS; if not, write to the Free Software Foundation,

20 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

21 */

23 #ifdef HAVE_CONFIG_H

24 #include <config.h>

25 #endif

27 #include <stdio.h>

28 #include <stdlib.h>

30 #if defined(_WIN32)

32 int main()

33 {

34 exit(77);

35 }

37 #else

39 #include <string.h>

40 #include <sys/types.h>

41 #include <netinet/in.h>

42 #include <sys/socket.h>

43 #include <sys/wait.h>

44 #include <arpa/inet.h>

45 #include <unistd.h>

46 #include <gnutls/gnutls.h>

47 #include <gnutls/dtls.h>

48 #include <signal.h>

50 #include "utils.h"

52 static void terminate(void);

54 /* This program tests the robustness of record

55 * decoding.

56 */

58 static void server_log_func(int level, const char *str)

59 {

60 fprintf(stderr, "server|<%d>| %s", level, str);

61 }

63 static void client_log_func(int level, const char *str)

64 {

65 fprintf(stderr, "client|<%d>| %s", level, str);

66 }

68 static unsigned char server_cert_pem[] =

69 "-----BEGIN CERTIFICATE-----\n"

70 "MIICVjCCAcGgAwIBAgIERiYdMTALBgkqhkiG9w0BAQUwGTEXMBUGA1UEAxMOR251\n"

71 "VExTIHRlc3QgQ0EwHhcNMDcwNDE4MTMyOTIxWhcNMDgwNDE3MTMyOTIxWjA3MRsw\n"

72 "GQYDVQQKExJHbnVUTFMgdGVzdCBzZXJ2ZXIxGDAWBgNVBAMTD3Rlc3QuZ251dGxz\n"

73 "Lm9yZzCBnDALBgkqhkiG9w0BAQEDgYwAMIGIAoGA17pcr6MM8C6pJ1aqU46o63+B\n"

74 "dUxrmL5K6rce+EvDasTaDQC46kwTHzYWk95y78akXrJutsoKiFV1kJbtple8DDt2\n"

75 "DZcevensf9Op7PuFZKBroEjOd35znDET/z3IrqVgbtm2jFqab7a+n2q9p/CgMyf1\n"

76 "tx2S5Zacc1LWn9bIjrECAwEAAaOBkzCBkDAMBgNVHRMBAf8EAjAAMBoGA1UdEQQT\n"

77 "MBGCD3Rlc3QuZ251dGxzLm9yZzATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHQ8B\n"

78 "Af8EBQMDB6AAMB0GA1UdDgQWBBTrx0Vu5fglyoyNgw106YbU3VW0dTAfBgNVHSME\n"

79 "GDAWgBTpPBz7rZJu5gakViyi4cBTJ8jylTALBgkqhkiG9w0BAQUDgYEAaFEPTt+7\n"

80 "bzvBuOf7+QmeQcn29kT6Bsyh1RHJXf8KTk5QRfwp6ogbp94JQWcNQ/S7YDFHglD1\n"

81 "AwUNBRXwd3riUsMnsxgeSDxYBfJYbDLeohNBsqaPDJb7XailWbMQKfAbFQ8cnOxg\n"

82 "rOKLUQRWJ0K3HyXRMhbqjdLIaQiCvQLuizo=\n" "-----END CERTIFICATE-----\n";

84 const gnutls_datum_t server_cert = { server_cert_pem,

85 sizeof(server_cert_pem)

86 };

88 static unsigned char server_key_pem[] =

89 "-----BEGIN RSA PRIVATE KEY-----\n"

90 "MIICXAIBAAKBgQDXulyvowzwLqknVqpTjqjrf4F1TGuYvkrqtx74S8NqxNoNALjq\n"

91 "TBMfNhaT3nLvxqResm62ygqIVXWQlu2mV7wMO3YNlx696ex/06ns+4VkoGugSM53\n"

92 "fnOcMRP/PciupWBu2baMWppvtr6far2n8KAzJ/W3HZLllpxzUtaf1siOsQIDAQAB\n"

93 "AoGAYAFyKkAYC/PYF8e7+X+tsVCHXppp8AoP8TEZuUqOZz/AArVlle/ROrypg5kl\n"

94 "8YunrvUdzH9R/KZ7saNZlAPLjZyFG9beL/am6Ai7q7Ma5HMqjGU8kTEGwD7K+lbG\n"

95 "iomokKMOl+kkbY/2sI5Czmbm+/PqLXOjtVc5RAsdbgvtmvkCQQDdV5QuU8jap8Hs\n"

96 "Eodv/tLJ2z4+SKCV2k/7FXSKWe0vlrq0cl2qZfoTUYRnKRBcWxc9o92DxK44wgPi\n"

97 "oMQS+O7fAkEA+YG+K9e60sj1K4NYbMPAbYILbZxORDecvP8lcphvwkOVUqbmxOGh\n"

98 "XRmTZUuhBrJhJKKf6u7gf3KWlPl6ShKEbwJASC118cF6nurTjuLf7YKARDjNTEws\n"

99 "qZEeQbdWYINAmCMj0RH2P0mvybrsXSOD5UoDAyO7aWuqkHGcCLv6FGG+qwJAOVqq\n"

100 "tXdUucl6GjOKKw5geIvRRrQMhb/m5scb+5iw8A4LEEHPgGiBaF5NtJZLALgWfo5n\n"

101 "hmC8+G8F0F78znQtPwJBANexu+Tg5KfOnzSILJMo3oXiXhf5PqXIDmbN0BKyCKAQ\n"

102 "LfkcEcUbVfmDaHpvzwY9VEaoMOKVLitETXdNSxVpvWM=\n"

103 "-----END RSA PRIVATE KEY-----\n";

104

105 const gnutls_datum_t server_key = { server_key_pem,

106 sizeof(server_key_pem)

107 };

108

109

110 /* A very basic TLS client, with anonymous authentication.

111 */

112

113 #define MAX_BUF 1024

114

115 static int to_send = -1;

116 static int mtu = 0;

117

118 static ssize_t

119 push(gnutls_transport_ptr_t tr, const void *data, size_t len)

120 {

121 int fd = (long int) tr;

122

123 return send(fd, data, len, 0);

124 }

125

126 #define RECORD_HEADER_SIZE (5+8)

127

128 static ssize_t

129 push_crippled(gnutls_transport_ptr_t tr, const void *data, size_t len)

130 {

131 int fd = (long int) tr;

132 int _len, ret;

133 uint8_t *_data = (void *) data;

134

135 if (to_send == -1)

136 return send(fd, data, len, 0);

137 else {

138 #if 0

139 _len =

140 ((uint8_t *) data)[11] << 8 | ((uint8_t *) data)[12];

141 fprintf(stderr, "mtu: %d, len: %d", mtu, (int) _len);

142 fprintf(stderr, " send: %d\n", (int) to_send);

143 #endif

144

145 _len = to_send;

146 _data[11] = _len >> 8;

147 _data[12] = _len;

148

149 /* correct len */

150 ret = send(fd, data, RECORD_HEADER_SIZE + _len, 0);

151

152 if (ret < 0)

153 return ret;

154

155 return len;

156 }

157 }

158

159 static void client(int fd, const char *prio)

160 {

161 int ret;

162 char buffer[MAX_BUF + 1];

163 gnutls_anon_client_credentials_t anoncred;

164 gnutls_certificate_credentials_t x509_cred;

165 gnutls_session_t session;

166 /* Need to enable anonymous KX specifically. */

167

168 global_init();

169

170 if (debug) {

171 gnutls_global_set_log_function(client_log_func);

172 gnutls_global_set_log_level(7);

173 }

174

175 gnutls_anon_allocate_client_credentials(&anoncred);

176 gnutls_certificate_allocate_credentials(&x509_cred);

177

178 /* Initialize TLS session

179 */

180 gnutls_init(&session, GNUTLS_CLIENT | GNUTLS_DATAGRAM);

181 gnutls_dtls_set_mtu(session, 1500);

182

183 /* Use default priorities */

184 gnutls_priority_set_direct(session, prio, NULL);

185

186 /* put the anonymous credentials to the current session

187 */

188 gnutls_credentials_set(session, GNUTLS_CRD_ANON, anoncred);

189 gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);

190

191 gnutls_transport_set_int(session, fd);

192 gnutls_transport_set_push_function(session, push);

193

194 /* Perform the TLS handshake

195 */

196 do {

197 ret = gnutls_handshake(session);

198 }

199 while (ret < 0 && gnutls_error_is_fatal(ret) == 0);

200

201 if (ret < 0) {

202 fail("client: Handshake failed\n");

203 gnutls_perror(ret);

204 exit(1);

205 } else {

206 if (debug)

207 success("client: Handshake was completed\n");

208 }

209

210 if (debug)

211 success("client: TLS version is: %s\n",

212 gnutls_protocol_get_name

213 (gnutls_protocol_get_version(session)));

214

215 do {

216 do {

217 ret = gnutls_record_recv(session, buffer, MAX_BUF);

218 } while (ret == GNUTLS_E_AGAIN

219 || ret == GNUTLS_E_INTERRUPTED);

220 } while (ret > 0);

221

222 if (ret == 0) {

223 if (debug)

224 success

225 ("client: Peer has closed the TLS connection\n");

226 goto end;

227 } else if (ret < 0) {

228 if (ret != 0) {

229 fail("client: Error: %s\n", gnutls_strerror(ret));

230 exit(1);

231 }

232 }

233

234 gnutls_bye(session, GNUTLS_SHUT_WR);

235

236 end:

237

238 close(fd);

239

240 gnutls_deinit(session);

241

242 gnutls_anon_free_client_credentials(anoncred);

243 gnutls_certificate_free_credentials(x509_cred);

244

245 gnutls_global_deinit();

246 }

247

248

249 /* These are global */

250 pid_t child;

251

252 static void terminate(void)

253 {

254 kill(child, SIGTERM);

255 exit(1);

256 }

257

258 static void server(int fd, const char *prio)

259 {

260 int ret;

261 char buffer[MAX_BUF + 1];

262 gnutls_session_t session;

263 gnutls_anon_server_credentials_t anoncred;

264 gnutls_certificate_credentials_t x509_cred;

265

266 /* this must be called once in the program

267 */

268 global_init();

269 memset(buffer, 0, sizeof(buffer));

270

271 if (debug) {

272 gnutls_global_set_log_function(server_log_func);

273 gnutls_global_set_log_level(4711);

274 }

275

276 gnutls_certificate_allocate_credentials(&x509_cred);

277 gnutls_certificate_set_x509_key_mem(x509_cred, &server_cert,

278 &server_key,

279 GNUTLS_X509_FMT_PEM);

280

281 gnutls_anon_allocate_server_credentials(&anoncred);

282

283 gnutls_init(&session, GNUTLS_SERVER | GNUTLS_DATAGRAM);

284 gnutls_dtls_set_mtu(session, 1500);

285

286 /* avoid calling all the priority functions, since the defaults

287 * are adequate.

288 */

289 gnutls_priority_set_direct(session, prio, NULL);

290

291 gnutls_credentials_set(session, GNUTLS_CRD_ANON, anoncred);

292 gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);

293

294 gnutls_transport_set_int(session, fd);

295 gnutls_transport_set_push_function(session, push_crippled);

296

297 do {

298 ret = gnutls_handshake(session);

299 }

300 while (ret < 0 && gnutls_error_is_fatal(ret) == 0);

301 if (ret < 0) {

302 close(fd);

303 gnutls_deinit(session);

304 fail("server: Handshake has failed (%s)\n\n",

305 gnutls_strerror(ret));

306 terminate();

307 }

308 if (debug)

309 success("server: Handshake was completed\n");

310

311 if (debug)

312 success("server: TLS version is: %s\n",

313 gnutls_protocol_get_name

314 (gnutls_protocol_get_version(session)));

315 mtu = gnutls_dtls_get_mtu(session);

316

317 do {

318 do {

319 ret =

320 gnutls_record_send(session, buffer,

321 sizeof(buffer));

322 } while (ret == GNUTLS_E_AGAIN

323 || ret == GNUTLS_E_INTERRUPTED);

324

325 if (ret < 0) {

326 fail("Error sending %d byte packet: %s\n", to_send,

327 gnutls_strerror(ret));

328 terminate();

329 }

330 to_send++;

331 }

332 while (to_send < 64);

333

334 to_send = -1;

335 /* do not wait for the peer to close the connection.

336 */

337 gnutls_bye(session, GNUTLS_SHUT_WR);

338

339 close(fd);

340 gnutls_deinit(session);

341

342 gnutls_anon_free_server_credentials(anoncred);

343 gnutls_certificate_free_credentials(x509_cred);

344

345 gnutls_global_deinit();

346

347 if (debug)

348 success("server: finished\n");

349 }

350

351 static void start(const char *prio)

352 {

353 int fd[2];

354 int ret;

355

356 ret = socketpair(AF_UNIX, SOCK_STREAM, 0, fd);

357 if (ret < 0) {

358 perror("socketpair");

359 exit(1);

360 }

361

362 child = fork();

363 if (child < 0) {

364 perror("fork");

365 fail("fork");

366 exit(1);

367 }

368

369 if (child) {

370 /* parent */

371 close(fd[1]);

372 server(fd[0], prio);

373 kill(child, SIGTERM);

374 } else {

375 close(fd[0]);

376 client(fd[1], prio);

377 exit(0);

378 }

379 }

380

381 #define AES_CBC "NONE:+VERS-DTLS1.0:-CIPHER-ALL:+AES-128-CBC:+SHA1:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL"

382 #define AES_CBC_SHA256 "NONE:+VERS-DTLS1.0:-CIPHER-ALL:+RSA:+AES-128-CBC:+AES-256-CBC:+SHA256:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL"

383 #define AES_GCM "NONE:+VERS-DTLS1.2:-CIPHER-ALL:+RSA:+AES-128-GCM:+MAC-ALL:+SIGN-ALL:+COMP-ALL:+ANON-ECDH:+CURVE-ALL"

384

385 static void ch_handler(int sig)

386 {

387 int status;

388 wait(&status);

389 if (WEXITSTATUS(status) != 0 ||

390 (WIFSIGNALED(status) && WTERMSIG(status) == SIGSEGV)) {

391 if (WIFSIGNALED(status))

392 fail("Child died with sigsegv\n");

393 else

394 fail("Child died with status %d\n",

395 WEXITSTATUS(status));

396 terminate();

397 }

398 return;

399 }

400

401 void doit(void)

402 {

403 signal(SIGCHLD, ch_handler);

404

405 start(AES_CBC);

406 start(AES_CBC_SHA256);

407 start(AES_GCM);

408 }

409

410 #endif /* _WIN32 */