/mandos/trunk : revision 237.2.14

36

#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */

37

38

#include <stdio.h> /* fprintf(), stderr, fwrite(),

39

stdout, ferror(), sscanf(),

40

remove() */

39

stdout, ferror(), remove() */

41

40

#include <stdint.h> /* uint16_t, uint32_t */

42

41

#include <stddef.h> /* NULL, size_t, ssize_t */

43

42

#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,

44

srand() */

43

srand(), strtof() */

45

44

#include <stdbool.h> /* bool, false, true */

46

45

#include <string.h> /* memset(), strcmp(), strlen(),

47

46

strerror(), asprintf(), strcpy() */

56

55

#include <fcntl.h> /* open() */

57

56

#include <dirent.h> /* opendir(), struct dirent, readdir()

58

57

*/

59

#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */

58

#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,

59

strtoimax() */

60

#include <assert.h> /* assert() */

61

#include <errno.h> /* perror(), errno */

62

#include <time.h> /* nanosleep(), time() */

75

argp_state, struct argp,

76

argp_parse(), ARGP_KEY_ARG,

77

ARGP_KEY_END, ARGP_ERR_UNKNOWN */

78

#include <signal.h> /* sigemptyset(), sigaddset(),

79

sigaction(), SIGTERM, sigaction,

80

sig_atomic_t */

81

78

82

#ifdef __linux__

79

83

#include <sys/klog.h> /* klogctl() */

80

#endif

84

#endif /* __linux__ */

81

85

82

86

/* Avahi */

83

87

/* All Avahi types, constants and functions

129

133

gpgme_ctx_t ctx;

130

134

} mandos_context;

131

135

136

/* global context so signal handler can reach it*/

137

mandos_context mc = { .simple_poll = NULL, .server = NULL,

138

.dh_bits = 1024, .priority = "SECURE256"

139

":!CTYPE-X.509:+CTYPE-OPENPGP" };

140

132

141

/*

133

* Make room in "buffer" for at least BUFFER_SIZE additional bytes.

134

* "buffer_capacity" is how much is currently allocated,

142

* Make additional room in "buffer" for at least BUFFER_SIZE more

143

* bytes. "buffer_capacity" is how much is currently allocated,

135

144

* "buffer_length" is how much is already used.

136

145

*/

137

size_t adjustbuffer(char **buffer, size_t buffer_length,

146

size_t incbuffer(char **buffer, size_t buffer_length,

138

147

size_t buffer_capacity){

139

148

if(buffer_length + BUFFER_SIZE > buffer_capacity){

140

149

*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);

149

158

/*

150

159

* Initialize GPGME.

151

160

*/

152

static bool init_gpgme(mandos_context *mc, const char *seckey,

161

static bool init_gpgme(const char *seckey,

153

162

const char *pubkey, const char *tempdir){

154

163

int ret;

155

164

gpgme_error_t rc;

176

185

return false;

177

186

}

178

187

179

rc = gpgme_op_import(mc->ctx, pgp_data);

188

rc = gpgme_op_import(mc.ctx, pgp_data);

180

189

if(rc != GPG_ERR_NO_ERROR){

181

190

fprintf(stderr, "bad gpgme_op_import: %s: %s\n",

182

191

gpgme_strsource(rc), gpgme_strerror(rc));

192

201

}

193

202

194

203

if(debug){

195

fprintf(stderr, "Initialize gpgme\n");

204

fprintf(stderr, "Initializing GPGME\n");

196

205

}

197

206

198

207

/* Init GPGME */

225

234

}

226

235

227

236

/* Create new GPGME "context" */

228

rc = gpgme_new(&(mc->ctx));

237

rc = gpgme_new(&(mc.ctx));

229

238

if(rc != GPG_ERR_NO_ERROR){

230

239

fprintf(stderr, "bad gpgme_new: %s: %s\n",

231

240

gpgme_strsource(rc), gpgme_strerror(rc));

243

252

* Decrypt OpenPGP data.

244

253

* Returns -1 on error

245

254

*/

246

static ssize_t pgp_packet_decrypt(const mandos_context *mc,

247

const char *cryptotext,

255

static ssize_t pgp_packet_decrypt(const char *cryptotext,

248

256

size_t crypto_size,

249

257

char **plaintext){

250

258

gpgme_data_t dh_crypto, dh_plain;

277

285

278

286

/* Decrypt data from the cryptotext data buffer to the plaintext

279

287

data buffer */

280

rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);

288

rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);

281

289

if(rc != GPG_ERR_NO_ERROR){

282

290

fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",

283

291

gpgme_strsource(rc), gpgme_strerror(rc));

284

292

plaintext_length = -1;

285

293

if(debug){

286

294

gpgme_decrypt_result_t result;

287

result = gpgme_op_decrypt_result(mc->ctx);

295

result = gpgme_op_decrypt_result(mc.ctx);

288

296

if(result == NULL){

289

297

fprintf(stderr, "gpgme_op_decrypt_result failed\n");

290

298

} else {

326

334

327

335

*plaintext = NULL;

328

336

while(true){

329

plaintext_capacity = adjustbuffer(plaintext,

337

plaintext_capacity = incbuffer(plaintext,

330

338

(size_t)plaintext_length,

331

339

plaintext_capacity);

332

340

if(plaintext_capacity == 0){

333

perror("adjustbuffer");

341

perror("incbuffer");

334

342

plaintext_length = -1;

335

343

goto decrypt_end;

336

344

}

382

390

fprintf(stderr, "GnuTLS: %s", string);

383

391

}

384

392

385

static int init_gnutls_global(mandos_context *mc,

386

const char *pubkeyfilename,

393

static int init_gnutls_global(const char *pubkeyfilename,

387

394

const char *seckeyfilename){

388

395

int ret;

389

396

407

414

}

408

415

409

416

/* OpenPGP credentials */

410

gnutls_certificate_allocate_credentials(&mc->cred);

417

gnutls_certificate_allocate_credentials(&mc.cred);

411

418

if(ret != GNUTLS_E_SUCCESS){

412

419

fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning

413

420

from

425

432

}

426

433

427

434

ret = gnutls_certificate_set_openpgp_key_file

428

(mc->cred, pubkeyfilename, seckeyfilename,

435

(mc.cred, pubkeyfilename, seckeyfilename,

429

436

GNUTLS_OPENPGP_FMT_BASE64);

430

437

if(ret != GNUTLS_E_SUCCESS){

431

438

fprintf(stderr,

437

444

}

438

445

439

446

/* GnuTLS server initialization */

440

ret = gnutls_dh_params_init(&mc->dh_params);

447

ret = gnutls_dh_params_init(&mc.dh_params);

441

448

if(ret != GNUTLS_E_SUCCESS){

442

449

fprintf(stderr, "Error in GnuTLS DH parameter initialization:"

443

450

" %s\n", safer_gnutls_strerror(ret));

444

451

goto globalfail;

445

452

}

446

ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);

453

ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);

447

454

if(ret != GNUTLS_E_SUCCESS){

448

455

fprintf(stderr, "Error in GnuTLS prime generation: %s\n",

449

456

safer_gnutls_strerror(ret));

450

457

goto globalfail;

451

458

}

452

459

453

gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);

460

gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);

454

461

455

462

return 0;

456

463

457

464

globalfail:

458

465

459

gnutls_certificate_free_credentials(mc->cred);

466

gnutls_certificate_free_credentials(mc.cred);

460

467

gnutls_global_deinit();

461

gnutls_dh_params_deinit(mc->dh_params);

468

gnutls_dh_params_deinit(mc.dh_params);

462

469

return -1;

463

470

}

464

471

465

static int init_gnutls_session(mandos_context *mc,

466

gnutls_session_t *session){

472

static int init_gnutls_session(gnutls_session_t *session){

467

473

int ret;

468

474

/* GnuTLS session creation */

469

475

ret = gnutls_init(session, GNUTLS_SERVER);

474

480

475

481

{

476

482

const char *err;

477

ret = gnutls_priority_set_direct(*session, mc->priority, &err);

483

ret = gnutls_priority_set_direct(*session, mc.priority, &err);

478

484

if(ret != GNUTLS_E_SUCCESS){

479

485

fprintf(stderr, "Syntax error at: %s\n", err);

480

486

fprintf(stderr, "GnuTLS error: %s\n",

485

491

}

486

492

487

493

ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,

488

mc->cred);

494

mc.cred);

489

495

if(ret != GNUTLS_E_SUCCESS){

490

496

fprintf(stderr, "Error setting GnuTLS credentials: %s\n",

491

497

safer_gnutls_strerror(ret));

497

503

gnutls_certificate_server_set_request(*session,

498

504

GNUTLS_CERT_IGNORE);

499

505

500

gnutls_dh_set_prime_bits(*session, mc->dh_bits);

506

gnutls_dh_set_prime_bits(*session, mc.dh_bits);

501

507

502

508

return 0;

503

509

}

509

515

/* Called when a Mandos server is found */

510

516

static int start_mandos_communication(const char *ip, uint16_t port,

511

517

AvahiIfIndex if_index,

512

mandos_context *mc, int af){

518

int af){

513

519

int ret, tcp_sd;

514

520

ssize_t sret;

515

521

union {

538

544

return -1;

539

545

}

540

546

541

ret = init_gnutls_session(mc, &session);

547

ret = init_gnutls_session(&session);

542

548

if(ret != 0){

543

549

return -1;

544

550

}

685

691

}

686

692

687

693

while(true){

688

buffer_capacity = adjustbuffer(&buffer, buffer_length,

694

buffer_capacity = incbuffer(&buffer, buffer_length,

689

695

buffer_capacity);

690

696

if(buffer_capacity == 0){

691

perror("adjustbuffer");

697

perror("incbuffer");

692

698

retval = -1;

693

699

goto mandos_end;

694

700

}

733

739

gnutls_bye(session, GNUTLS_SHUT_RDWR);

734

740

735

741

if(buffer_length > 0){

736

decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,

742

decrypted_buffer_size = pgp_packet_decrypt(buffer,

737

743

buffer_length,

738

744

&decrypted_buffer);

739

745

if(decrypted_buffer_size >= 0){

785

791

AVAHI_GCC_UNUSED AvahiStringList *txt,

786

792

AVAHI_GCC_UNUSED AvahiLookupResultFlags

787

793

flags,

788

void* userdata){

789

mandos_context *mc = userdata;

794

AVAHI_GCC_UNUSED void* userdata){

790

795

assert(r);

791

796

792

797

/* Called whenever a service has been resolved successfully or

797

802

case AVAHI_RESOLVER_FAILURE:

798

803

fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"

799

804

" of type '%s' in domain '%s': %s\n", name, type, domain,

800

avahi_strerror(avahi_server_errno(mc->server)));

805

avahi_strerror(avahi_server_errno(mc.server)));

801

806

break;

802

807

803

808

case AVAHI_RESOLVER_FOUND:

809

814

PRIdMAX ") on port %" PRIu16 "\n", name, host_name,

810

815

ip, (intmax_t)interface, port);

811

816

}

812

int ret = start_mandos_communication(ip, port, interface, mc,

817

int ret = start_mandos_communication(ip, port, interface,

813

818

avahi_proto_to_af(proto));

814

819

if(ret == 0){

815

avahi_simple_poll_quit(mc->simple_poll);

820

avahi_simple_poll_quit(mc.simple_poll);

816

821

}

817

822

}

818

823

}

828

833

const char *domain,

829

834

AVAHI_GCC_UNUSED AvahiLookupResultFlags

830

835

flags,

831

void* userdata){

832

mandos_context *mc = userdata;

836

AVAHI_GCC_UNUSED void* userdata){

833

837

assert(b);

834

838

835

839

/* Called whenever a new services becomes available on the LAN or

840

844

case AVAHI_BROWSER_FAILURE:

841

845

842

846

fprintf(stderr, "(Avahi browser) %s\n",

843

avahi_strerror(avahi_server_errno(mc->server)));

844

avahi_simple_poll_quit(mc->simple_poll);

847

avahi_strerror(avahi_server_errno(mc.server)));

848

avahi_simple_poll_quit(mc.simple_poll);

845

849

return;

846

850

847

851

case AVAHI_BROWSER_NEW:

850

854

the callback function is called the Avahi server will free the

851

855

resolver for us. */

852

856

853

if(!(avahi_s_service_resolver_new(mc->server, interface,

854

protocol, name, type, domain,

855

AVAHI_PROTO_INET6, 0,

856

resolve_callback, mc)))

857

if(avahi_s_service_resolver_new(mc.server, interface, protocol,

858

name, type, domain, protocol, 0,

859

resolve_callback, NULL) == NULL)

857

860

fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",

858

name, avahi_strerror(avahi_server_errno(mc->server)));

861

name, avahi_strerror(avahi_server_errno(mc.server)));

859

862

break;

860

863

861

864

case AVAHI_BROWSER_REMOVE:

870

873

}

871

874

}

872

875

876

sig_atomic_t quit_now = 0;

877

878

/* stop main loop after sigterm has been called */

879

static void handle_sigterm(__attribute__((unused)) int sig){

880

if(quit_now){

881

return;

882

}

883

quit_now = 1;

884

int old_errno = errno;

885

if(mc.simple_poll != NULL){

886

avahi_simple_poll_quit(mc.simple_poll);

887

}

888

errno = old_errno;

889

}

890

873

891

int main(int argc, char *argv[]){

874

892

AvahiSServiceBrowser *sb = NULL;

875

893

int error;

876

894

int ret;

877

895

intmax_t tmpmax;

878

int numchars;

896

char *tmp;

879

897

int exitcode = EXIT_SUCCESS;

880

898

const char *interface = "eth0";

881

899

struct ifreq network;

889

907

const char *seckey = PATHDIR "/" SECKEY;

890

908

const char *pubkey = PATHDIR "/" PUBKEY;

891

909

892

mandos_context mc = { .simple_poll = NULL, .server = NULL,

893

.dh_bits = 1024, .priority = "SECURE256"

894

":!CTYPE-X.509:+CTYPE-OPENPGP" };

895

910

bool gnutls_initialized = false;

896

911

bool gpgme_initialized = false;

897

double delay = 2.5;

912

float delay = 2.5f;

913

914

struct sigaction old_sigterm_action;

915

struct sigaction sigterm_action = { .sa_handler = handle_sigterm };

898

916

899

917

{

900

918

struct argp_option options[] = {

952

970

pubkey = arg;

953

971

break;

954

972

case 129: /* --dh-bits */

955

ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);

956

if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax

957

or arg[numchars] != '\0'){

973

errno = 0;

974

tmpmax = strtoimax(arg, &tmp, 10);

975

if(errno != 0 or tmp == arg or *tmp != '\0'

976

or tmpmax != (typeof(mc.dh_bits))tmpmax){

958

977

fprintf(stderr, "Bad number of DH bits\n");

959

978

exit(EXIT_FAILURE);

960

979

}

964

983

mc.priority = arg;

965

984

break;

966

985

case 131: /* --delay */

967

ret = sscanf(arg, "%lf%n", &delay, &numchars);

968

if(ret < 1 or arg[numchars] != '\0'){

986

errno = 0;

987

delay = strtof(arg, &tmp);

988

if(errno != 0 or tmp == arg or *tmp != '\0'){

969

989

fprintf(stderr, "Bad delay\n");

970

990

exit(EXIT_FAILURE);

971

991

}

992

1012

}

993

1013

}

994

1014

1015

if(not debug){

1016

avahi_set_log_function(empty_log);

1017

}

1018

1019

/* Initialize Avahi early so avahi_simple_poll_quit() can be called

1020

from the signal handler */

1021

/* Initialize the pseudo-RNG for Avahi */

1022

srand((unsigned int) time(NULL));

1023

mc.simple_poll = avahi_simple_poll_new();

1024

if(mc.simple_poll == NULL){

1025

fprintf(stderr, "Avahi: Failed to create simple poll object.\n");

1026

exitcode = EXIT_FAILURE;

1027

goto end;

1028

}

1029

1030

sigemptyset(&sigterm_action.sa_mask);

1031

ret = sigaddset(&sigterm_action.sa_mask, SIGINT);

1032

if(ret == -1){

1033

perror("sigaddset");

1034

exitcode = EXIT_FAILURE;

1035

goto end;

1036

}

1037

ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);

1038

if(ret == -1){

1039

perror("sigaddset");

1040

exitcode = EXIT_FAILURE;

1041

goto end;

1042

}

1043

ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);

1044

if(ret == -1){

1045

perror("sigaddset");

1046

exitcode = EXIT_FAILURE;

1047

goto end;

1048

}

1049

ret = sigaction(SIGTERM, &sigterm_action, &old_sigterm_action);

1050

if(ret == -1){

1051

perror("sigaction");

1052

exitcode = EXIT_FAILURE;

1053

goto end;

1054

}

1055

995

1056

/* If the interface is down, bring it up */

996

1057

if(interface[0] != '\0'){

997

1058

#ifdef __linux__

1003

1064

restore_loglevel = false;

1004

1065

perror("klogctl");

1005

1066

}

1006

#endif

1067

#endif /* __linux__ */

1007

1068

1008

1069

sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1009

1070

if(sd < 0){

1016

1077

perror("klogctl");

1017

1078

}

1018

1079

}

1019

#endif

1080

#endif /* __linux__ */

1020

1081

goto end;

1021

1082

}

1022

1083

strcpy(network.ifr_name, interface);

1030

1091

perror("klogctl");

1031

1092

}

1032

1093

}

1033

#endif

1094

#endif /* __linux__ */

1034

1095

exitcode = EXIT_FAILURE;

1035

1096

goto end;

1036

1097

}

1047

1108

perror("klogctl");

1048

1109

}

1049

1110

}

1050

#endif

1111

#endif /* __linux__ */

1051

1112

goto end;

1052

1113

}

1053

1114

}

1077

1138

perror("klogctl");

1078

1139

}

1079

1140

}

1080

#endif

1141

#endif /* __linux__ */

1081

1142

}

1082

1143

1083

1144

uid = getuid();

1094

1155

perror("setuid");

1095

1156

}

1096

1157

1097

ret = init_gnutls_global(&mc, pubkey, seckey);

1158

ret = init_gnutls_global(pubkey, seckey);

1098

1159

if(ret == -1){

1099

1160

fprintf(stderr, "init_gnutls_global failed\n");

1100

1161

exitcode = EXIT_FAILURE;

1109

1170

}

1110

1171

tempdir_created = true;

1111

1172

1112

if(not init_gpgme(&mc, pubkey, seckey, tempdir)){

1173

if(not init_gpgme(pubkey, seckey, tempdir)){

1113

1174

fprintf(stderr, "init_gpgme failed\n");

1114

1175

exitcode = EXIT_FAILURE;

1115

1176

goto end;

1136

1197

goto end;

1137

1198

}

1138

1199

uint16_t port;

1139

ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);

1140

if(ret < 1 or tmpmax != (uint16_t)tmpmax

1141

or address[numchars+1] != '\0'){

1200

errno = 0;

1201

tmpmax = strtoimax(address+1, &tmp, 10);

1202

if(errno != 0 or tmp == address+1 or *tmp != '\0'

1203

or tmpmax != (uint16_t)tmpmax){

1142

1204

fprintf(stderr, "Bad port number\n");

1143

1205

exitcode = EXIT_FAILURE;

1144

1206

goto end;

1153

1215

} else {

1154

1216

af = AF_INET;

1155

1217

}

1156

ret = start_mandos_communication(address, port, if_index, &mc,

1157

af);

1218

ret = start_mandos_communication(address, port, if_index, af);

1158

1219

if(ret < 0){

1159

1220

exitcode = EXIT_FAILURE;

1160

1221

} else {

1162

1223

}

1163

1224

goto end;

1164

1225

}

1165

1166

if(not debug){

1167

avahi_set_log_function(empty_log);

1168

}

1169

1170

/* Initialize the pseudo-RNG for Avahi */

1171

srand((unsigned int) time(NULL));

1172

1173

/* Allocate main Avahi loop object */

1174

mc.simple_poll = avahi_simple_poll_new();

1175

if(mc.simple_poll == NULL){

1176

fprintf(stderr, "Avahi: Failed to create simple poll object.\n");

1177

exitcode = EXIT_FAILURE;

1178

goto end;

1179

}

1180

1226

1181

1227

{

1182

1228

AvahiServerConfig config;

1183

1229

/* Do not publish any local Zeroconf records */

1206

1252

1207

1253

/* Create the Avahi service browser */

1208

1254

sb = avahi_s_service_browser_new(mc.server, if_index,

1209

AVAHI_PROTO_INET6, "_mandos._tcp",

1210

NULL, 0, browse_callback, &mc);

1255

AVAHI_PROTO_UNSPEC, "_mandos._tcp",

1256

NULL, 0, browse_callback, NULL);

1211

1257

if(sb == NULL){

1212

1258

fprintf(stderr, "Failed to create service browser: %s\n",

1213

1259

avahi_strerror(avahi_server_errno(mc.server)));