/mandos/trunk : revision 312

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,

857

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

854

858

protocol, name, type, domain,

855

859

AVAHI_PROTO_INET6, 0,

856

resolve_callback, mc)))

860

resolve_callback, NULL)))

857

861

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

858

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

862

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

859

863

break;

860

864

861

865

case AVAHI_BROWSER_REMOVE:

870

874

}

871

875

}

872

876

877

sig_atomic_t quit_now = 0;

878

879

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

880

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

881

if(quit_now){

882

return;

883

}

884

quit_now = 1;

885

int old_errno = errno;

886

if(mc.simple_poll != NULL){

887

avahi_simple_poll_quit(mc.simple_poll);

888

}

889

errno = old_errno;

890

}

891

873

892

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

874

893

AvahiSServiceBrowser *sb = NULL;

875

894

int error;

876

895

int ret;

877

896

intmax_t tmpmax;

878

int numchars;

897

char *tmp;

879

898

int exitcode = EXIT_SUCCESS;

880

899

const char *interface = "eth0";

881

900

struct ifreq network;

889

908

const char *seckey = PATHDIR "/" SECKEY;

890

909

const char *pubkey = PATHDIR "/" PUBKEY;

891

910

892

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

893

.dh_bits = 1024, .priority = "SECURE256"

894

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

911

/* Initialize Mandos context */

912

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

913

.dh_bits = 1024, .priority = "SECURE256"

914

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

895

915

bool gnutls_initialized = false;

896

916

bool gpgme_initialized = false;

897

double delay = 2.5;

917

float delay = 2.5f;

918

919

struct sigaction old_sigterm_action;

920

struct sigaction sigterm_action = { .sa_handler = handle_sigterm };

898

921

899

922

{

900

923

struct argp_option options[] = {

952

975

pubkey = arg;

953

976

break;

954

977

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'){

978

errno = 0;

979

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

980

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

981

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

958

982

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

959

983

exit(EXIT_FAILURE);

960

984

}

964

988

mc.priority = arg;

965

989

break;

966

990

case 131: /* --delay */

967

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

968

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

991

errno = 0;

992

delay = strtof(arg, &tmp);

993

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

969

994

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

970

995

exit(EXIT_FAILURE);

971

996

}

992

1017

}

993

1018

}

994

1019

1020

if(not debug){

1021

avahi_set_log_function(empty_log);

1022

}

1023

1024

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

1025

from the signal handler */

1026

/* Initialize the pseudo-RNG for Avahi */

1027

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

1028

mc.simple_poll = avahi_simple_poll_new();

1029

if(mc.simple_poll == NULL){

1030

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

1031

exitcode = EXIT_FAILURE;

1032

goto end;

1033

}

1034

1035

sigemptyset(&sigterm_action.sa_mask);

1036

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

1037

if(ret == -1){

1038

perror("sigaddset");

1039

exitcode = EXIT_FAILURE;

1040

goto end;

1041

}

1042

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

1043

if(ret == -1){

1044

perror("sigaddset");

1045

exitcode = EXIT_FAILURE;

1046

goto end;

1047

}

1048

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

1049

if(ret == -1){

1050

perror("sigaddset");

1051

exitcode = EXIT_FAILURE;

1052

goto end;

1053

}

1054

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

1055

if(ret == -1){

1056

perror("sigaction");

1057

exitcode = EXIT_FAILURE;

1058

goto end;

1059

}

1060

995

1061

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

996

1062

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

997

1063

#ifdef __linux__

1003

1069

restore_loglevel = false;

1004

1070

perror("klogctl");

1005

1071

}

1006

#endif

1072

#endif /* __linux__ */

1007

1073

1008

1074

sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1009

1075

if(sd < 0){

1016

1082

perror("klogctl");

1017

1083

}

1018

1084

}

1019

#endif

1085

#endif /* __linux__ */

1020

1086

goto end;

1021

1087

}

1022

1088

strcpy(network.ifr_name, interface);

1030

1096

perror("klogctl");

1031

1097

}

1032

1098

}

1033

#endif

1099

#endif /* __linux__ */

1034

1100

exitcode = EXIT_FAILURE;

1035

1101

goto end;

1036

1102

}

1047

1113

perror("klogctl");

1048

1114

}

1049

1115

}

1050

#endif

1116

#endif /* __linux__ */

1051

1117

goto end;

1052

1118

}

1053

1119

}

1077

1143

perror("klogctl");

1078

1144

}

1079

1145

}

1080

#endif

1146

#endif /* __linux__ */

1081

1147

}

1082

1148

1083

1149

uid = getuid();

1094

1160

perror("setuid");

1095

1161

}

1096

1162

1097

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

1163

ret = init_gnutls_global(pubkey, seckey);

1098

1164

if(ret == -1){

1099

1165

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

1100

1166

exitcode = EXIT_FAILURE;

1109

1175

}

1110

1176

tempdir_created = true;

1111

1177

1112

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

1178

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

1113

1179

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

1114

1180

exitcode = EXIT_FAILURE;

1115

1181

goto end;

1136

1202

goto end;

1137

1203

}

1138

1204

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'){

1205

errno = 0;

1206

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

1207

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

1208

or tmpmax != (uint16_t)tmpmax){

1142

1209

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

1143

1210

exitcode = EXIT_FAILURE;

1144

1211

goto end;

1153

1220

} else {

1154

1221

af = AF_INET;

1155

1222

}

1156

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

1157

af);

1223

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

1158

1224

if(ret < 0){

1159

1225

exitcode = EXIT_FAILURE;

1160

1226

} else {

1162

1228

}

1163

1229

goto end;

1164

1230

}

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

1231

1181

1232

{

1182

1233

AvahiServerConfig config;

1183

1234

/* Do not publish any local Zeroconf records */

1207

1258

/* Create the Avahi service browser */

1208

1259

sb = avahi_s_service_browser_new(mc.server, if_index,

1209

1260

AVAHI_PROTO_INET6, "_mandos._tcp",

1210

NULL, 0, browse_callback, &mc);

1261

NULL, 0, browse_callback, NULL);

1211

1262

if(sb == NULL){

1212

1263

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

1213

1264

avahi_strerror(avahi_server_errno(mc.server)));