/mandos/release : revision 237.7.8

9

* "browse_callback", and parts of "main".

10

*

11

* Everything else is

12

13

12

13

14

*

15

* This program is free software: you can redistribute it and/or

16

* modify it under the terms of the GNU General Public License as

26

* along with this program. If not, see

27

* <http://www.gnu.org/licenses/>.

28

*

29

* Contact the authors at <mandos@recompile.se>.

29

* Contact the authors at <mandos@fukt.bsnet.se>.

30

*/

31

32

/* Needed by GPGME, specifically gpgme_data_seek() */

62

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

63

strtoimax() */

64

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

65

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

66

program_invocation_short_name */

65

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

67

66

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

68

67

#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,

69

68

SIOCSIFFLAGS, if_indextoname(),

74

73

#include <unistd.h> /* close(), SEEK_SET, off_t, write(),

75

74

getuid(), getgid(), seteuid(),

76

75

setgid(), pause() */

77

#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */

76

#include <arpa/inet.h> /* inet_pton(), htons */

78

77

#include <iso646.h> /* not, or, and */

79

78

#include <argp.h> /* struct argp_option, error_t, struct

80

79

argp_state, struct argp,

123

122

#define PATHDIR "/conf/conf.d/mandos"

124

123

#define SECKEY "seckey.txt"

125

124

#define PUBKEY "pubkey.txt"

126

#define HOOKDIR "/lib/mandos/network-hooks.d"

127

125

128

126

bool debug = false;

129

127

static const char mandos_protocol_version[] = "1";

130

128

const char *argp_program_version = "mandos-client " VERSION;

131

const char *argp_program_bug_address = "<mandos@recompile.se>";

129

const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";

132

130

static const char sys_class_net[] = "/sys/class/net";

133

131

char *connect_to = NULL;

134

132

135

/* Doubly linked list that need to be circularly linked when used */

136

typedef struct server{

137

const char *ip;

138

uint16_t port;

139

AvahiIfIndex if_index;

140

int af;

141

struct timespec last_seen;

142

struct server *next;

143

struct server *prev;

144

} server;

145

146

133

/* Used for passing in values through the Avahi callback functions */

147

134

typedef struct {

148

135

AvahiSimplePoll *simple_poll;

152

139

gnutls_dh_params_t dh_params;

153

140

const char *priority;

154

141

gpgme_ctx_t ctx;

155

server *current_server;

156

142

} mandos_context;

157

143

158

144

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

159

145

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

160

146

.dh_bits = 1024, .priority = "SECURE256"

161

":!CTYPE-X.509:+CTYPE-OPENPGP",

162

.current_server = NULL };

147

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

163

148

164

149

sig_atomic_t quit_now = 0;

165

150

int signal_received = 0;

166

151

167

/* Function to use when printing errors */

168

void perror_plus(const char *print_text){

169

fprintf(stderr, "Mandos plugin %s: ",

170

program_invocation_short_name);

171

perror(print_text);

172

}

173

174

int fprintf_plus(FILE *stream, const char *format, ...){

175

va_list ap;

176

va_start (ap, format);

177

178

TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ", program_invocation_short_name));

179

return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));

180

}

181

182

152

/*

183

153

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

184

154

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

196

166

return buffer_capacity;

197

167

}

198

168

199

/* Add server to set of servers to retry periodically */

200

int add_server(const char *ip, uint16_t port,

201

AvahiIfIndex if_index,

202

int af){

203

int ret;

204

server *new_server = malloc(sizeof(server));

205

if(new_server == NULL){

206

perror_plus("malloc");

207

return -1;

208

}

209

*new_server = (server){ .ip = strdup(ip),

210

.port = port,

211

.if_index = if_index,

212

.af = af };

213

if(new_server->ip == NULL){

214

perror_plus("strdup");

215

return -1;

216

}

217

/* Special case of first server */

218

if (mc.current_server == NULL){

219

new_server->next = new_server;

220

new_server->prev = new_server;

221

mc.current_server = new_server;

222

/* Place the new server last in the list */

223

} else {

224

new_server->next = mc.current_server;

225

new_server->prev = mc.current_server->prev;

226

new_server->prev->next = new_server;

227

mc.current_server->prev = new_server;

228

}

229

ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);

230

if(ret == -1){

231

perror_plus("clock_gettime");

232

return -1;

233

}

234

return 0;

235

}

236

237

169

/*

238

170

* Initialize GPGME.

239

171

*/

253

185

254

186

fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));

255

187

if(fd == -1){

256

perror_plus("open");

188

perror("open");

257

189

return false;

258

190

}

259

191

273

205

274

206

ret = (int)TEMP_FAILURE_RETRY(close(fd));

275

207

if(ret == -1){

276

perror_plus("close");

208

perror("close");

277

209

}

278

210

gpgme_data_release(pgp_data);

279

211

return true;

292

224

return false;

293

225

}

294

226

295

/* Set GPGME home directory for the OpenPGP engine only */

227

/* Set GPGME home directory for the OpenPGP engine only */

296

228

rc = gpgme_get_engine_info(&engine_info);

297

229

if(rc != GPG_ERR_NO_ERROR){

298

230

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

404

336

405

337

/* Seek back to the beginning of the GPGME plaintext data buffer */

406

338

if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){

407

perror_plus("gpgme_data_seek");

339

perror("gpgme_data_seek");

408

340

plaintext_length = -1;

409

341

goto decrypt_end;

410

342

}

415

347

(size_t)plaintext_length,

416

348

plaintext_capacity);

417

349

if(plaintext_capacity == 0){

418

perror_plus("incbuffer");

350

perror("incbuffer");

419

351

plaintext_length = -1;

420

352

goto decrypt_end;

421

353

}

428

360

break;

429

361

}

430

362

if(ret < 0){

431

perror_plus("gpgme_data_read");

363

perror("gpgme_data_read");

432

364

plaintext_length = -1;

433

365

goto decrypt_end;

434

366

}

491

423

}

492

424

493

425

/* OpenPGP credentials */

494

ret = gnutls_certificate_allocate_credentials(&mc.cred);

426

gnutls_certificate_allocate_credentials(&mc.cred);

495

427

if(ret != GNUTLS_E_SUCCESS){

496

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

428

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

429

from

430

-Wunreachable-code

431

*/

497

432

safer_gnutls_strerror(ret));

498

433

gnutls_global_deinit();

499

434

return -1;

654

589

tcp_sd = socket(pf, SOCK_STREAM, 0);

655

590

if(tcp_sd < 0){

656

591

int e = errno;

657

perror_plus("socket");

592

perror("socket");

658

593

errno = e;

659

594

goto mandos_end;

660

595

}

674

609

}

675

610

if(ret < 0 ){

676

611

int e = errno;

677

perror_plus("inet_pton");

612

perror("inet_pton");

678

613

errno = e;

679

614

goto mandos_end;

680

615

}

716

651

if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){

717

652

char interface[IF_NAMESIZE];

718

653

if(if_indextoname((unsigned int)if_index, interface) == NULL){

719

perror_plus("if_indextoname");

654

perror("if_indextoname");

720

655

} else {

721

656

fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",

722

657

ip, interface, port);

736

671

sizeof(addrstr));

737

672

}

738

673

if(pcret == NULL){

739

perror_plus("inet_ntop");

674

perror("inet_ntop");

740

675

} else {

741

676

if(strcmp(addrstr, ip) != 0){

742

677

fprintf(stderr, "Canonical address form: %s\n", addrstr);

757

692

if(ret < 0){

758

693

if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){

759

694

int e = errno;

760

perror_plus("connect");

695

perror("connect");

761

696

errno = e;

762

697

}

763

698

goto mandos_end;

776

711

out_size - written));

777

712

if(ret == -1){

778

713

int e = errno;

779

perror_plus("write");

714

perror("write");

780

715

errno = e;

781

716

goto mandos_end;

782

717

}

807

742

goto mandos_end;

808

743

}

809

744

810

/* Spurious warning from -Wint-to-pointer-cast */

811

745

gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);

812

746

813

747

if(quit_now){

850

784

buffer_capacity);

851

785

if(buffer_capacity == 0){

852

786

int e = errno;

853

perror_plus("incbuffer");

787

perror("incbuffer");

854

788

errno = e;

855

789

goto mandos_end;

856

790

}

961

895

if(e == 0){

962

896

e = errno;

963

897

}

964

perror_plus("close");

898

perror("close");

965

899

}

966

900

gnutls_deinit(session);

967

errno = e;

968

901

if(quit_now){

969

errno = EINTR;

902

e = EINTR;

970

903

retval = -1;

971

904

}

905

errno = e;

972

906

}

973

907

return retval;

974

908

}

1017

951

avahi_proto_to_af(proto));

1018

952

if(ret == 0){

1019

953

avahi_simple_poll_quit(mc.simple_poll);

1020

} else {

1021

ret = add_server(ip, port, interface,

1022

avahi_proto_to_af(proto));

1023

954

}

1024

955

}

1025

956

}

1079

1010

}

1080

1011

}

1081

1012

1082

/* Signal handler that stops main loop after SIGTERM */

1013

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

1083

1014

static void handle_sigterm(int sig){

1084

1015

if(quit_now){

1085

1016

return;

1087

1018

quit_now = 1;

1088

1019

signal_received = sig;

1089

1020

int old_errno = errno;

1090

/* set main loop to exit */

1091

1021

if(mc.simple_poll != NULL){

1092

1022

avahi_simple_poll_quit(mc.simple_poll);

1093

1023

}

1094

1024

errno = old_errno;

1095

1025

}

1096

1026

1097

bool get_flags(const char *ifname, struct ifreq *ifr){

1098

int ret;

1099

1100

int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1101

if(s < 0){

1102

perror_plus("socket");

1103

return false;

1104

}

1105

strcpy(ifr->ifr_name, ifname);

1106

ret = ioctl(s, SIOCGIFFLAGS, ifr);

1107

if(ret == -1){

1108

if(debug){

1109

perror_plus("ioctl SIOCGIFFLAGS");

1110

}

1111

return false;

1112

}

1113

return true;

1114

}

1115

1116

bool good_flags(const char *ifname, const struct ifreq *ifr){

1117

1118

/* Reject the loopback device */

1119

if(ifr->ifr_flags & IFF_LOOPBACK){

1120

if(debug){

1121

fprintf(stderr, "Rejecting loopback interface \"%s\"\n",

1122

ifname);

1123

}

1124

return false;

1125

}

1126

/* Accept point-to-point devices only if connect_to is specified */

1127

if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){

1128

if(debug){

1129

fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",

1130

ifname);

1131

}

1132

return true;

1133

}

1134

/* Otherwise, reject non-broadcast-capable devices */

1135

if(not (ifr->ifr_flags & IFF_BROADCAST)){

1136

if(debug){

1137

fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",

1138

ifname);

1139

}

1140

return false;

1141

}

1142

/* Reject non-ARP interfaces (including dummy interfaces) */

1143

if(ifr->ifr_flags & IFF_NOARP){

1144

if(debug){

1145

fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n", ifname);

1146

}

1147

return false;

1148

}

1149

1150

/* Accept this device */

1151

if(debug){

1152

fprintf(stderr, "Interface \"%s\" is good\n", ifname);

1153

}

1154

return true;

1155

}

1156

1157

1027

/*

1158

1028

* This function determines if a directory entry in /sys/class/net

1159

1029

* corresponds to an acceptable network device.

1160

1030

* (This function is passed to scandir(3) as a filter function.)

1161

1031

*/

1162

1032

int good_interface(const struct dirent *if_entry){

1163

int ret;

1164

if(if_entry->d_name[0] == '.'){

1165

return 0;

1166

}

1167

struct ifreq ifr;

1168

1169

if(not get_flags(if_entry->d_name, &ifr)){

1170

return 0;

1171

}

1172

1173

if(not good_flags(if_entry->d_name, &ifr)){

1174

return 0;

1175

}

1176

return 1;

1177

}

1178

1179

/*

1180

* This function determines if a directory entry in /sys/class/net

1181

* corresponds to an acceptable network device which is up.

1182

* (This function is passed to scandir(3) as a filter function.)

1183

*/

1184

int up_interface(const struct dirent *if_entry){

1185

1033

ssize_t ssret;

1186

1034

char *flagname = NULL;

1187

if(if_entry->d_name[0] == '.'){

1188

return 0;

1189

}

1190

1035

int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,

1191

1036

if_entry->d_name);

1192

1037

if(ret < 0){

1193

perror_plus("asprintf");

1038

perror("asprintf");

1039

return 0;

1040

}

1041

if(if_entry->d_name[0] == '.'){

1194

1042

return 0;

1195

1043

}

1196

1044

int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));

1197

1045

if(flags_fd == -1){

1198

perror_plus("open");

1199

free(flagname);

1046

perror("open");

1200

1047

return 0;

1201

1048

}

1202

free(flagname);

1203

1049

typedef short ifreq_flags; /* ifreq.ifr_flags in netdevice(7) */

1204

1050

/* read line from flags_fd */

1205

ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */

1051

ssize_t to_read = (sizeof(ifreq_flags)*2)+3; /* "0x1003\n" */

1206

1052

char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */

1207

1053

flagstring[(size_t)to_read] = '\0';

1208

1054

if(flagstring == NULL){

1209

perror_plus("malloc");

1055

perror("malloc");

1210

1056

close(flags_fd);

1211

1057

return 0;

1212

1058

}

1214

1060

ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,

1215

1061

(size_t)to_read));

1216

1062

if(ssret == -1){

1217

perror_plus("read");

1063

perror("read");

1218

1064

free(flagstring);

1219

1065

close(flags_fd);

1220

1066

return 0;

1249

1095

}

1250

1096

return 0;

1251

1097

}

1252

1253

/* Reject down interfaces */

1254

if(not (flags & IFF_UP)){

1255

return 0;

1256

}

1257

1258

1098

/* Accept point-to-point devices only if connect_to is specified */

1259

1099

if(connect_to != NULL and (flags & IFF_POINTOPOINT)){

1260

1100

if(debug){

1271

1111

}

1272

1112

return 0;

1273

1113

}

1274

/* Reject non-ARP interfaces (including dummy interfaces) */

1275

if(flags & IFF_NOARP){

1276

if(debug){

1277

fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",

1278

if_entry->d_name);

1279

}

1280

return 0;

1281

}

1282

1114

/* Accept this device */

1283

1115

if(debug){

1284

1116

fprintf(stderr, "Interface \"%s\" is acceptable\n",

1287

1119

return 1;

1288

1120

}

1289

1121

1290

int notdotentries(const struct dirent *direntry){

1291

/* Skip "." and ".." */

1292

if(direntry->d_name[0] == '.'

1293

and (direntry->d_name[1] == '\0'

1294

or (direntry->d_name[1] == '.'

1295

and direntry->d_name[2] == '\0'))){

1296

return 0;

1297

}

1298

return 1;

1299

}

1300

1301

/* Is this directory entry a runnable program? */

1302

int runnable_hook(const struct dirent *direntry){

1303

int ret;

1304

struct stat st;

1305

1306

if((direntry->d_name)[0] == '\0'){

1307

/* Empty name? */

1308

return 0;

1309

}

1310

1311

/* Save pointer to last character */

1312

char *end = strchr(direntry->d_name, '\0')-1;

1313

1314

if(*end == '~'){

1315

/* Backup name~ */

1316

return 0;

1317

}

1318

1319

if(((direntry->d_name)[0] == '#')

1320

and (*end == '#')){

1321

/* Temporary #name# */

1322

return 0;

1323

}

1324

1325

/* XXX more rules here */

1326

1327

ret = stat(direntry->d_name, &st);

1328

if(ret == -1){

1329

if(debug){

1330

perror_plus("Could not stat plugin");

1331

}

1332

return 0;

1333

}

1334

if(not (st.st_mode & S_ISREG)){

1335

/* Not a regular file */

1336

return 0;

1337

}

1338

if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){

1339

/* Not executable */

1340

return 0;

1341

}

1342

return 1;

1343

}

1344

1345

int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){

1346

int ret;

1347

struct timespec now;

1348

struct timespec waited_time;

1349

intmax_t block_time;

1350

1351

while(true){

1352

if(mc.current_server == NULL){

1353

if (debug){

1354

fprintf(stderr,

1355

"Wait until first server is found. No timeout!\n");

1356

}

1357

ret = avahi_simple_poll_iterate(s, -1);

1358

} else {

1359

if (debug){

1360

fprintf(stderr, "Check current_server if we should run it,"

1361

" or wait\n");

1362

}

1363

/* the current time */

1364

ret = clock_gettime(CLOCK_MONOTONIC, &now);

1365

if(ret == -1){

1366

perror_plus("clock_gettime");

1367

return -1;

1368

}

1369

/* Calculating in ms how long time between now and server

1370

who we visted longest time ago. Now - last seen. */

1371

waited_time.tv_sec = (now.tv_sec

1372

- mc.current_server->last_seen.tv_sec);

1373

waited_time.tv_nsec = (now.tv_nsec

1374

- mc.current_server->last_seen.tv_nsec);

1375

/* total time is 10s/10,000ms.

1376

Converting to s from ms by dividing by 1,000,

1377

and ns to ms by dividing by 1,000,000. */

1378

block_time = ((retry_interval

1379

- ((intmax_t)waited_time.tv_sec * 1000))

1380

- ((intmax_t)waited_time.tv_nsec / 1000000));

1381

1382

if (debug){

1383

fprintf(stderr, "Blocking for %" PRIdMAX " ms\n", block_time);

1384

}

1385

1386

if(block_time <= 0){

1387

ret = start_mandos_communication(mc.current_server->ip,

1388

mc.current_server->port,

1389

mc.current_server->if_index,

1390

mc.current_server->af);

1391

if(ret == 0){

1392

avahi_simple_poll_quit(mc.simple_poll);

1393

return 0;

1394

}

1395

ret = clock_gettime(CLOCK_MONOTONIC,

1396

&mc.current_server->last_seen);

1397

if(ret == -1){

1398

perror_plus("clock_gettime");

1399

return -1;

1400

}

1401

mc.current_server = mc.current_server->next;

1402

block_time = 0; /* Call avahi to find new Mandos

1403

servers, but don't block */

1404

}

1405

1406

ret = avahi_simple_poll_iterate(s, (int)block_time);

1407

}

1408

if(ret != 0){

1409

if (ret > 0 or errno != EINTR) {

1410

return (ret != 1) ? ret : 0;

1411

}

1412

}

1413

}

1414

}

1415

1416

1122

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

1417

1123

AvahiSServiceBrowser *sb = NULL;

1418

1124

int error;

1435

1141

bool gnutls_initialized = false;

1436

1142

bool gpgme_initialized = false;

1437

1143

float delay = 2.5f;

1438

double retry_interval = 10; /* 10s between trying a server and

1439

retrying the same server again */

1440

1144

1441

1145

struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };

1442

1146

struct sigaction sigterm_action = { .sa_handler = handle_sigterm };

1448

1152

errno = 0;

1449

1153

ret = setgid(gid);

1450

1154

if(ret == -1){

1451

perror_plus("setgid");

1155

perror("setgid");

1452

1156

}

1453

1157

1454

1158

/* Lower user privileges (temporarily) */

1455

1159

errno = 0;

1456

1160

ret = seteuid(uid);

1457

1161

if(ret == -1){

1458

perror_plus("seteuid");

1162

perror("seteuid");

1459

1163

}

1460

1164

1461

1165

if(quit_now){

1496

1200

.arg = "SECONDS",

1497

1201

.doc = "Maximum delay to wait for interface startup",

1498

1202

.group = 2 },

1499

{ .name = "retry", .key = 132,

1500

.arg = "SECONDS",

1501

.doc = "Retry interval used when denied by the mandos server",

1502

.group = 2 },

1503

1203

/*

1504

1204

* These reproduce what we would get without ARGP_NO_HELP

1505

1205

*/

1549

1249

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

1550

1250

argp_error(state, "Bad delay");

1551

1251

}

1552

case 132: /* --retry */

1553

errno = 0;

1554

retry_interval = strtod(arg, &tmp);

1555

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

1556

or (retry_interval * 1000) > INT_MAX

1557

or retry_interval < 0){

1558

argp_error(state, "Bad retry interval");

1559

}

1560

1252

break;

1561

1253

/*

1562

1254

* These reproduce what we would get without ARGP_NO_HELP

1590

1282

case ENOMEM:

1591

1283

default:

1592

1284

errno = ret;

1593

perror_plus("argp_parse");

1285

perror("argp_parse");

1594

1286

exitcode = EX_OSERR;

1595

1287

goto end;

1596

1288

case EINVAL:

1598

1290

goto end;

1599

1291

}

1600

1292

}

1601

1602

{

1603

/* Work around Debian bug #633582:

1604

<http://bugs.debian.org/633582> */

1605

struct stat st;

1606

1607

/* Re-raise priviliges */

1608

errno = 0;

1609

ret = seteuid(0);

1610

if(ret == -1){

1611

perror_plus("seteuid");

1612

}

1613

1614

if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){

1615

int seckey_fd = open(seckey, O_RDONLY);

1616

if(seckey_fd == -1){

1617

perror_plus("open");

1618

} else {

1619

ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));

1620

if(ret == -1){

1621

perror_plus("fstat");

1622

} else {

1623

if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){

1624

ret = fchown(seckey_fd, uid, gid);

1625

if(ret == -1){

1626

perror_plus("fchown");

1627

}

1628

}

1629

}

1630

TEMP_FAILURE_RETRY(close(seckey_fd));

1631

}

1632

}

1633

1634

if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){

1635

int pubkey_fd = open(pubkey, O_RDONLY);

1636

if(pubkey_fd == -1){

1637

perror_plus("open");

1638

} else {

1639

ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));

1640

if(ret == -1){

1641

perror_plus("fstat");

1642

} else {

1643

if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){

1644

ret = fchown(pubkey_fd, uid, gid);

1645

if(ret == -1){

1646

perror_plus("fchown");

1647

}

1648

}

1649

}

1650

TEMP_FAILURE_RETRY(close(pubkey_fd));

1651

}

1652

}

1653

1654

/* Lower privileges */

1655

errno = 0;

1656

ret = seteuid(uid);

1657

if(ret == -1){

1658

perror_plus("seteuid");

1659

}

1660

}

1661

1662

/* Find network hooks and run them */

1663

{

1664

struct dirent **direntries;

1665

struct dirent *direntry;

1666

int numhooks = scandir(HOOKDIR, &direntries, runnable_hook,

1667

alphasort);

1668

int devnull = open("/dev/null", O_RDONLY);

1669

for(int i = 0; i < numhooks; i++){

1670

direntry = direntries[0];

1671

char *fullname = NULL;

1672

ret = asprintf(&fullname, "%s/%s", tempdir,

1673

direntry->d_name);

1674

if(ret < 0){

1675

perror_plus("asprintf");

1676

continue;

1677

}

1678

pid_t hook_pid = fork();

1679

if(hook_pid == 0){

1680

/* Child */

1681

dup2(devnull, STDIN_FILENO);

1682

close(devnull);

1683

dup2(STDERR_FILENO, STDOUT_FILENO);

1684

setenv("DEVICE", interface, 1);

1685

setenv("VERBOSE", debug ? "1" : "0", 1);

1686

setenv("MODE", "start", 1);

1687

/* setenv( XXX more here */

1688

ret = execl(fullname, direntry->d_name, "start");

1689

perror_plus("execl");

1690

}

1691

free(fullname);

1692

if(quit_now){

1693

goto end;

1694

}

1695

}

1696

close(devnull);

1697

}

1698

1293

1699

1294

if(not debug){

1700

1295

avahi_set_log_function(empty_log);

1701

1296

}

1702

1297

1703

1298

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

1704

1299

struct dirent **direntries;

1705

1300

ret = scandir(sys_class_net, &direntries, good_interface,

1711

1306

fprintf(stderr, "Using interface \"%s\"\n", interface);

1712

1307

}

1713

1308

if(interface == NULL){

1714

perror_plus("malloc");

1309

perror("malloc");

1715

1310

free(direntries);

1716

1311

exitcode = EXIT_FAILURE;

1717

1312

goto end;

1739

1334

sigemptyset(&sigterm_action.sa_mask);

1740

1335

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

1741

1336

if(ret == -1){

1742

perror_plus("sigaddset");

1337

perror("sigaddset");

1743

1338

exitcode = EX_OSERR;

1744

1339

goto end;

1745

1340

}

1746

1341

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

1747

1342

if(ret == -1){

1748

perror_plus("sigaddset");

1343

perror("sigaddset");

1749

1344

exitcode = EX_OSERR;

1750

1345

goto end;

1751

1346

}

1752

1347

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

1753

1348

if(ret == -1){

1754

perror_plus("sigaddset");

1349

perror("sigaddset");

1755

1350

exitcode = EX_OSERR;

1756

1351

goto end;

1757

1352

}

1761

1356

*/

1762

1357

ret = sigaction(SIGINT, NULL, &old_sigterm_action);

1763

1358

if(ret == -1){

1764

perror_plus("sigaction");

1359

perror("sigaction");

1765

1360

return EX_OSERR;

1766

1361

}

1767

1362

if(old_sigterm_action.sa_handler != SIG_IGN){

1768

1363

ret = sigaction(SIGINT, &sigterm_action, NULL);

1769

1364

if(ret == -1){

1770

perror_plus("sigaction");

1365

perror("sigaction");

1771

1366

exitcode = EX_OSERR;

1772

1367

goto end;

1773

1368

}

1774

1369

}

1775

1370

ret = sigaction(SIGHUP, NULL, &old_sigterm_action);

1776

1371

if(ret == -1){

1777

perror_plus("sigaction");

1372

perror("sigaction");

1778

1373

return EX_OSERR;

1779

1374

}

1780

1375

if(old_sigterm_action.sa_handler != SIG_IGN){

1781

1376

ret = sigaction(SIGHUP, &sigterm_action, NULL);

1782

1377

if(ret == -1){

1783

perror_plus("sigaction");

1378

perror("sigaction");

1784

1379

exitcode = EX_OSERR;

1785

1380

goto end;

1786

1381

}

1787

1382

}

1788

1383

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

1789

1384

if(ret == -1){

1790

perror_plus("sigaction");

1385

perror("sigaction");

1791

1386

return EX_OSERR;

1792

1387

}

1793

1388

if(old_sigterm_action.sa_handler != SIG_IGN){

1794

1389

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

1795

1390

if(ret == -1){

1796

perror_plus("sigaction");

1391

perror("sigaction");

1797

1392

exitcode = EX_OSERR;

1798

1393

goto end;

1799

1394

}

1816

1411

errno = 0;

1817

1412

ret = seteuid(0);

1818

1413

if(ret == -1){

1819

perror_plus("seteuid");

1414

perror("seteuid");

1820

1415

}

1821

1416

1822

1417

#ifdef __linux__

1826

1421

bool restore_loglevel = true;

1827

1422

if(ret == -1){

1828

1423

restore_loglevel = false;

1829

perror_plus("klogctl");

1424

perror("klogctl");

1830

1425

}

1831

1426

#endif /* __linux__ */

1832

1427

1833

1428

sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1834

1429

if(sd < 0){

1835

perror_plus("socket");

1430

perror("socket");

1836

1431

exitcode = EX_OSERR;

1837

1432

#ifdef __linux__

1838

1433

if(restore_loglevel){

1839

1434

ret = klogctl(7, NULL, 0);

1840

1435

if(ret == -1){

1841

perror_plus("klogctl");

1436

perror("klogctl");

1842

1437

}

1843

1438

}

1844

1439

#endif /* __linux__ */

1846

1441

errno = 0;

1847

1442

ret = seteuid(uid);

1848

1443

if(ret == -1){

1849

perror_plus("seteuid");

1444

perror("seteuid");

1850

1445

}

1851

1446

goto end;

1852

1447

}

1853

1448

strcpy(network.ifr_name, interface);

1854

1449

ret = ioctl(sd, SIOCGIFFLAGS, &network);

1855

1450

if(ret == -1){

1856

perror_plus("ioctl SIOCGIFFLAGS");

1451

perror("ioctl SIOCGIFFLAGS");

1857

1452

#ifdef __linux__

1858

1453

if(restore_loglevel){

1859

1454

ret = klogctl(7, NULL, 0);

1860

1455

if(ret == -1){

1861

perror_plus("klogctl");

1456

perror("klogctl");

1862

1457

}

1863

1458

}

1864

1459

#endif /* __linux__ */

1867

1462

errno = 0;

1868

1463

ret = seteuid(uid);

1869

1464

if(ret == -1){

1870

perror_plus("seteuid");

1465

perror("seteuid");

1871

1466

}

1872

1467

goto end;

1873

1468

}

1877

1472

ret = ioctl(sd, SIOCSIFFLAGS, &network);

1878

1473

if(ret == -1){

1879

1474

take_down_interface = false;

1880

perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");

1475

perror("ioctl SIOCSIFFLAGS +IFF_UP");

1881

1476

exitcode = EX_OSERR;

1882

1477

#ifdef __linux__

1883

1478

if(restore_loglevel){

1884

1479

ret = klogctl(7, NULL, 0);

1885

1480

if(ret == -1){

1886

perror_plus("klogctl");

1481

perror("klogctl");

1887

1482

}

1888

1483

}

1889

1484

#endif /* __linux__ */

1891

1486

errno = 0;

1892

1487

ret = seteuid(uid);

1893

1488

if(ret == -1){

1894

perror_plus("seteuid");

1489

perror("seteuid");

1895

1490

}

1896

1491

goto end;

1897

1492

}

1898

1493

}

1899

/* Sleep checking until interface is running.

1900

Check every 0.25s, up to total time of delay */

1494

/* sleep checking until interface is running */

1901

1495

for(int i=0; i < delay * 4; i++){

1902

1496

ret = ioctl(sd, SIOCGIFFLAGS, &network);

1903

1497

if(ret == -1){

1904

perror_plus("ioctl SIOCGIFFLAGS");

1498

perror("ioctl SIOCGIFFLAGS");

1905

1499

} else if(network.ifr_flags & IFF_RUNNING){

1906

1500

break;

1907

1501

}

1908

1502

struct timespec sleeptime = { .tv_nsec = 250000000 };

1909

1503

ret = nanosleep(&sleeptime, NULL);

1910

1504

if(ret == -1 and errno != EINTR){

1911

perror_plus("nanosleep");

1505

perror("nanosleep");

1912

1506

}

1913

1507

}

1914

1508

if(not take_down_interface){

1915

1509

/* We won't need the socket anymore */

1916

1510

ret = (int)TEMP_FAILURE_RETRY(close(sd));

1917

1511

if(ret == -1){

1918

perror_plus("close");

1512

perror("close");

1919

1513

}

1920

1514

}

1921

1515

#ifdef __linux__

1923

1517

/* Restores kernel loglevel to default */

1924

1518

ret = klogctl(7, NULL, 0);

1925

1519

if(ret == -1){

1926

perror_plus("klogctl");

1520

perror("klogctl");

1927

1521

}

1928

1522

}

1929

1523

#endif /* __linux__ */

1933

1527

/* Lower privileges */

1934

1528

ret = seteuid(uid);

1935

1529

if(ret == -1){

1936

perror_plus("seteuid");

1530

perror("seteuid");

1937

1531

}

1938

1532

} else {

1939

1533

/* Lower privileges permanently */

1940

1534

ret = setuid(uid);

1941

1535

if(ret == -1){

1942

perror_plus("setuid");

1536

perror("setuid");

1943

1537

}

1944

1538

}

1945

1539

}

1961

1555

goto end;

1962

1556

}

1963

1557

1558

tempdir_created = true;

1964

1559

if(mkdtemp(tempdir) == NULL){

1965

perror_plus("mkdtemp");

1560

tempdir_created = false;

1561

perror("mkdtemp");

1966

1562

goto end;

1967

1563

}

1968

tempdir_created = true;

1969

1564

1970

1565

if(quit_now){

1971

1566

goto end;

2013

1608

2014

1609

port = (uint16_t)tmpmax;

2015

1610

*address = '\0';

1611

address = connect_to;

2016

1612

/* Colon in address indicates IPv6 */

2017

1613

int af;

2018

if(strchr(connect_to, ':') != NULL){

1614

if(strchr(address, ':') != NULL){

2019

1615

af = AF_INET6;

2020

/* Accept [] around IPv6 address - see RFC 5952 */

2021

if(connect_to[0] == '[' and address[-1] == ']')

2022

{

2023

connect_to++;

2024

address[-1] = '\0';

2025

}

2026

1616

} else {

2027

1617

af = AF_INET;

2028

1618

}

2029

address = connect_to;

2030

1619

2031

1620

if(quit_now){

2032

1621

goto end;

2033

1622

}

2034

1623

2035

1624

while(not quit_now){

2036

1625

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

2037

1626

if(quit_now or ret == 0){

2038

1627

break;

2039

1628

}

2040

if(debug){

2041

fprintf(stderr, "Retrying in %d seconds\n",

2042

(int)retry_interval);

2043

}

2044

sleep((int)retry_interval);

2045

}

2046

1629

sleep(15);

1630

};

1631

2047

1632

if (not quit_now){

2048

1633

exitcode = EXIT_SUCCESS;

2049

1634

}

2050

1635

2051

1636

goto end;

2052

1637

}

2053

1638

2105

1690

if(debug){

2106

1691

fprintf(stderr, "Starting Avahi loop search\n");

2107

1692

}

2108

2109

ret = avahi_loop_with_timeout(mc.simple_poll,

2110

(int)(retry_interval * 1000));

2111

if(debug){

2112

fprintf(stderr, "avahi_loop_with_timeout exited %s\n",

2113

(ret == 0) ? "successfully" : "with error");

2114

}

1693

1694

avahi_simple_poll_loop(mc.simple_poll);

2115

1695

2116

1696

end:

2117

1697

2138

1718

if(gpgme_initialized){

2139

1719

gpgme_release(mc.ctx);

2140

1720

}

2141

2142

/* Cleans up the circular linked list of Mandos servers the client

2143

has seen */

2144

if(mc.current_server != NULL){

2145

mc.current_server->prev->next = NULL;

2146

while(mc.current_server != NULL){

2147

server *next = mc.current_server->next;

2148

free(mc.current_server);

2149

mc.current_server = next;

2150

}

2151

}

2152

2153

/* XXX run network hooks "stop" here */

2154

1721

2155

1722

/* Take down the network interface */

2156

1723

if(take_down_interface){

2158

1725

errno = 0;

2159

1726

ret = seteuid(0);

2160

1727

if(ret == -1){

2161

perror_plus("seteuid");

1728

perror("seteuid");

2162

1729

}

2163

1730

if(geteuid() == 0){

2164

1731

ret = ioctl(sd, SIOCGIFFLAGS, &network);

2165

1732

if(ret == -1){

2166

perror_plus("ioctl SIOCGIFFLAGS");

1733

perror("ioctl SIOCGIFFLAGS");

2167

1734

} else if(network.ifr_flags & IFF_UP) {

2168

1735

network.ifr_flags &= ~(short)IFF_UP; /* clear flag */

2169

1736

ret = ioctl(sd, SIOCSIFFLAGS, &network);

2170

1737

if(ret == -1){

2171

perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");

1738

perror("ioctl SIOCSIFFLAGS -IFF_UP");

2172

1739

}

2173

1740

}

2174

1741

ret = (int)TEMP_FAILURE_RETRY(close(sd));

2175

1742

if(ret == -1){

2176

perror_plus("close");

1743

perror("close");

2177

1744

}

2178

1745

/* Lower privileges permanently */

2179

1746

errno = 0;

2180

1747

ret = setuid(uid);

2181

1748

if(ret == -1){

2182

perror_plus("setuid");

1749

perror("setuid");

2183

1750

}

2184

1751

}

2185

1752

}

2186

1753

2187

/* Removes the GPGME temp directory and all files inside */

1754

/* Removes the temp directory used by GPGME */

2188

1755

if(tempdir_created){

2189

struct dirent **direntries = NULL;

2190

struct dirent *direntry = NULL;

2191

int numentries = scandir(tempdir, &direntries, notdotentries,

2192

alphasort);

2193

if (numentries > 0){

2194

for(int i = 0; i < numentries; i++){

2195

direntry = direntries[i];

1756

DIR *d;

1757

struct dirent *direntry;

1758

d = opendir(tempdir);

1759

if(d == NULL){

1760

if(errno != ENOENT){

1761

perror("opendir");

1762

}

1763

} else {

1764

while(true){

1765

direntry = readdir(d);

1766

if(direntry == NULL){

1767

break;

1768

}

1769

/* Skip "." and ".." */

1770

if(direntry->d_name[0] == '.'

1771

and (direntry->d_name[1] == '\0'

1772

or (direntry->d_name[1] == '.'

1773

and direntry->d_name[2] == '\0'))){

1774

continue;

1775

}

2196

1776

char *fullname = NULL;

2197

1777

ret = asprintf(&fullname, "%s/%s", tempdir,

2198

1778

direntry->d_name);

2199

1779

if(ret < 0){

2200

perror_plus("asprintf");

1780

perror("asprintf");

2201

1781

continue;

2202

1782

}

2203

1783

ret = remove(fullname);

2207

1787

}

2208

1788

free(fullname);

2209

1789

}

2210

}

2211

2212

/* need to clean even if 0 because man page doesn't specify */

2213

free(direntries);

2214

if (numentries == -1){

2215

perror_plus("scandir");

1790

closedir(d);

2216

1791

}

2217

1792

ret = rmdir(tempdir);

2218

1793

if(ret == -1 and errno != ENOENT){

2219

perror_plus("rmdir");

1794

perror("rmdir");

2220

1795

}

2221

1796

}

2222

1797

2227

1802

&old_sigterm_action,

2228

1803

NULL));

2229

1804

if(ret == -1){

2230

perror_plus("sigaction");

1805

perror("sigaction");

2231

1806

}

2232

1807

do {

2233

1808

ret = raise(signal_received);

2234

1809

} while(ret != 0 and errno == EINTR);

2235

1810

if(ret != 0){

2236

perror_plus("raise");

1811

perror("raise");

2237

1812

abort();

2238

1813

}

2239

1814

TEMP_FAILURE_RETRY(pause());