/mandos/release : revision 296

11

# "AvahiService" class, and some lines in "main".

12

#

13

# Everything else is

14

15

14

15

16

#

17

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

18

# it under the terms of the GNU General Public License as published by

63

import cPickle as pickle

64

import multiprocessing

65

import types

66

import binascii

67

import tempfile

66

68

67

69

import dbus

68

70

import dbus.service

73

75

import ctypes.util

74

76

import xml.dom.minidom

75

77

import inspect

78

import GnuPGInterface

76

79

77

80

try:

78

81

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

82

85

except ImportError:

83

86

SO_BINDTODEVICE = None

84

87

85

86

version = "1.4.0"

87

88

#logger = logging.getLogger('mandos')

89

logger = logging.Logger('mandos')

88

version = "1.5.2"

89

stored_state_file = "clients.pickle"

90

91

logger = logging.getLogger()

90

92

syslogger = (logging.handlers.SysLogHandler

91

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

92

94

address = str("/dev/log")))

93

syslogger.setFormatter(logging.Formatter

94

('Mandos [%(process)d]: %(levelname)s:'

95

' %(message)s'))

96

logger.addHandler(syslogger)

97

98

console = logging.StreamHandler()

99

console.setFormatter(logging.Formatter('%(name)s [%(process)d]:'

100

' %(levelname)s:'

101

' %(message)s'))

102

logger.addHandler(console)

95

96

try:

97

if_nametoindex = (ctypes.cdll.LoadLibrary

98

(ctypes.util.find_library("c"))

99

.if_nametoindex)

100

except (OSError, AttributeError):

101

def if_nametoindex(interface):

102

"Get an interface index the hard way, i.e. using fcntl()"

103

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

104

with contextlib.closing(socket.socket()) as s:

105

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

106

struct.pack(str("16s16x"),

107

interface))

108

interface_index = struct.unpack(str("I"),

109

ifreq[16:20])[0]

110

return interface_index

111

112

113

def initlogger(debug, level=logging.WARNING):

114

"""init logger and add loglevel"""

115

116

syslogger.setFormatter(logging.Formatter

117

('Mandos [%(process)d]: %(levelname)s:'

118

' %(message)s'))

119

logger.addHandler(syslogger)

120

121

if debug:

122

console = logging.StreamHandler()

123

console.setFormatter(logging.Formatter('%(asctime)s %(name)s'

124

' [%(process)d]:'

125

' %(levelname)s:'

126

' %(message)s'))

127

logger.addHandler(console)

128

logger.setLevel(level)

129

130

131

class PGPError(Exception):

132

"""Exception if encryption/decryption fails"""

133

pass

134

135

136

class PGPEngine(object):

137

"""A simple class for OpenPGP symmetric encryption & decryption"""

138

def __init__(self):

139

self.gnupg = GnuPGInterface.GnuPG()

140

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

141

self.gnupg = GnuPGInterface.GnuPG()

142

self.gnupg.options.meta_interactive = False

143

self.gnupg.options.homedir = self.tempdir

144

self.gnupg.options.extra_args.extend(['--force-mdc',

145

'--quiet',

146

'--no-use-agent'])

147

148

def __enter__(self):

149

return self

150

151

def __exit__ (self, exc_type, exc_value, traceback):

152

self._cleanup()

153

return False

154

155

def __del__(self):

156

self._cleanup()

157

158

def _cleanup(self):

159

if self.tempdir is not None:

160

# Delete contents of tempdir

161

for root, dirs, files in os.walk(self.tempdir,

162

topdown = False):

163

for filename in files:

164

os.remove(os.path.join(root, filename))

165

for dirname in dirs:

166

os.rmdir(os.path.join(root, dirname))

167

# Remove tempdir

168

os.rmdir(self.tempdir)

169

self.tempdir = None

170

171

def password_encode(self, password):

172

# Passphrase can not be empty and can not contain newlines or

173

# NUL bytes. So we prefix it and hex encode it.

174

return b"mandos" + binascii.hexlify(password)

175

176

def encrypt(self, data, password):

177

self.gnupg.passphrase = self.password_encode(password)

178

with open(os.devnull) as devnull:

179

try:

180

proc = self.gnupg.run(['--symmetric'],

181

create_fhs=['stdin', 'stdout'],

182

attach_fhs={'stderr': devnull})

183

with contextlib.closing(proc.handles['stdin']) as f:

184

f.write(data)

185

with contextlib.closing(proc.handles['stdout']) as f:

186

ciphertext = f.read()

187

proc.wait()

188

except IOError as e:

189

raise PGPError(e)

190

self.gnupg.passphrase = None

191

return ciphertext

192

193

def decrypt(self, data, password):

194

self.gnupg.passphrase = self.password_encode(password)

195

with open(os.devnull) as devnull:

196

try:

197

proc = self.gnupg.run(['--decrypt'],

198

create_fhs=['stdin', 'stdout'],

199

attach_fhs={'stderr': devnull})

200

with contextlib.closing(proc.handles['stdin'] ) as f:

201

f.write(data)

202

with contextlib.closing(proc.handles['stdout']) as f:

203

decrypted_plaintext = f.read()

204

proc.wait()

205

except IOError as e:

206

raise PGPError(e)

207

self.gnupg.passphrase = None

208

return decrypted_plaintext

209

210

103

211

104

212

class AvahiError(Exception):

105

213

def __init__(self, value, *args, **kwargs):

164

272

.GetAlternativeServiceName(self.name))

165

273

logger.info("Changing Zeroconf service name to %r ...",

166

274

self.name)

167

syslogger.setFormatter(logging.Formatter

168

('Mandos (%s) [%%(process)d]:'

169

' %%(levelname)s: %%(message)s'

170

% self.name))

171

275

self.remove()

172

276

try:

173

277

self.add()

193

297

avahi.DBUS_INTERFACE_ENTRY_GROUP)

194

298

self.entry_group_state_changed_match = (

195

299

self.group.connect_to_signal(

196

'StateChanged', self .entry_group_state_changed))

300

'StateChanged', self.entry_group_state_changed))

197

301

logger.debug("Adding Zeroconf service '%s' of type '%s' ...",

198

302

self.name, self.type)

199

303

self.group.AddService(

225

329

try:

226

330

self.group.Free()

227

331

except (dbus.exceptions.UnknownMethodException,

228

dbus.exceptions.DBusException) as e:

332

dbus.exceptions.DBusException):

229

333

pass

230

334

self.group = None

231

335

self.remove()

265

369

self.server_state_changed)

266

370

self.server_state_changed(self.server.GetState())

267

371

372

class AvahiServiceToSyslog(AvahiService):

373

def rename(self):

374

"""Add the new name to the syslog messages"""

375

ret = AvahiService.rename(self)

376

syslogger.setFormatter(logging.Formatter

377

('Mandos (%s) [%%(process)d]:'

378

' %%(levelname)s: %%(message)s'

379

% self.name))

380

return ret

268

381

269

def _timedelta_to_milliseconds(td):

382

def timedelta_to_milliseconds(td):

270

383

"Convert a datetime.timedelta() to milliseconds"

271

384

return ((td.days * 24 * 60 * 60 * 1000)

272

385

+ (td.seconds * 1000)

276

389

"""A representation of a client host served by this server.

277

390

278

391

Attributes:

279

_approved: bool(); 'None' if not yet approved/disapproved

392

approved: bool(); 'None' if not yet approved/disapproved

280

393

approval_delay: datetime.timedelta(); Time to wait for approval

281

394

approval_duration: datetime.timedelta(); Duration of one approval

282

395

checker: subprocess.Popen(); a running checker process used

289

402

instance %(name)s can be used in the command.

290

403

checker_initiator_tag: a gobject event source tag, or None

291

404

created: datetime.datetime(); (UTC) object creation

405

client_structure: Object describing what attributes a client has

406

and is used for storing the client at exit

292

407

current_checker_command: string; current running checker_command

293

disable_hook: If set, called by disable() as disable_hook(self)

294

408

disable_initiator_tag: a gobject event source tag, or None

295

409

enabled: bool()

296

410

fingerprint: string (40 or 32 hexadecimal digits); used to

299

413

interval: datetime.timedelta(); How often to start a new checker

300

414

last_approval_request: datetime.datetime(); (UTC) or None

301

415

last_checked_ok: datetime.datetime(); (UTC) or None

302

last_enabled: datetime.datetime(); (UTC)

416

last_checker_status: integer between 0 and 255 reflecting exit

417

status of last checker. -1 reflects crashed

418

checker, -2 means no checker completed yet.

419

last_enabled: datetime.datetime(); (UTC) or None

303

420

name: string; from the config file, used in log messages and

304

421

D-Bus identifiers

305

422

secret: bytestring; sent verbatim (over TLS) to client

306

423

timeout: datetime.timedelta(); How long from last_checked_ok

307

424

until this client is disabled

308

extended_timeout: extra long timeout when password has been sent

425

extended_timeout: extra long timeout when secret has been sent

309

426

runtime_expansions: Allowed attributes for runtime expansion.

310

427

expires: datetime.datetime(); time (UTC) when a client will be

311

428

disabled, or None

315

432

"created", "enabled", "fingerprint",

316

433

"host", "interval", "last_checked_ok",

317

434

"last_enabled", "name", "timeout")

435

client_defaults = { "timeout": "5m",

436

"extended_timeout": "15m",

437

"interval": "2m",

438

"checker": "fping -q -- %%(host)s",

439

"host": "",

440

"approval_delay": "0s",

441

"approval_duration": "1s",

442

"approved_by_default": "True",

443

"enabled": "True",

444

}

318

445

319

446

def timeout_milliseconds(self):

320

447

"Return the 'timeout' attribute in milliseconds"

321

return _timedelta_to_milliseconds(self.timeout)

448

return timedelta_to_milliseconds(self.timeout)

322

449

323

450

def extended_timeout_milliseconds(self):

324

451

"Return the 'extended_timeout' attribute in milliseconds"

325

return _timedelta_to_milliseconds(self.extended_timeout)

452

return timedelta_to_milliseconds(self.extended_timeout)

326

453

327

454

def interval_milliseconds(self):

328

455

"Return the 'interval' attribute in milliseconds"

329

return _timedelta_to_milliseconds(self.interval)

456

return timedelta_to_milliseconds(self.interval)

330

457

331

458

def approval_delay_milliseconds(self):

332

return _timedelta_to_milliseconds(self.approval_delay)

333

334

def __init__(self, name = None, disable_hook=None, config=None):

459

return timedelta_to_milliseconds(self.approval_delay)

460

461

@staticmethod

462

def config_parser(config):

463

"""Construct a new dict of client settings of this form:

464

{ client_name: {setting_name: value, ...}, ...}

465

with exceptions for any special settings as defined above.

466

NOTE: Must be a pure function. Must return the same result

467

value given the same arguments.

468

"""

469

settings = {}

470

for client_name in config.sections():

471

section = dict(config.items(client_name))

472

client = settings[client_name] = {}

473

474

client["host"] = section["host"]

475

# Reformat values from string types to Python types

476

client["approved_by_default"] = config.getboolean(

477

client_name, "approved_by_default")

478

client["enabled"] = config.getboolean(client_name,

479

"enabled")

480

481

client["fingerprint"] = (section["fingerprint"].upper()

482

.replace(" ", ""))

483

if "secret" in section:

484

client["secret"] = section["secret"].decode("base64")

485

elif "secfile" in section:

486

with open(os.path.expanduser(os.path.expandvars

487

(section["secfile"])),

488

"rb") as secfile:

489

client["secret"] = secfile.read()

490

else:

491

raise TypeError("No secret or secfile for section %s"

492

% section)

493

client["timeout"] = string_to_delta(section["timeout"])

494

client["extended_timeout"] = string_to_delta(

495

section["extended_timeout"])

496

client["interval"] = string_to_delta(section["interval"])

497

client["approval_delay"] = string_to_delta(

498

section["approval_delay"])

499

client["approval_duration"] = string_to_delta(

500

section["approval_duration"])

501

client["checker_command"] = section["checker"]

502

client["last_approval_request"] = None

503

client["last_checked_ok"] = None

504

client["last_checker_status"] = -2

505

506

return settings

507

508

509

def __init__(self, settings, name = None):

335

510

"""Note: the 'checker' key in 'config' sets the

336

511

'checker_command' attribute and *not* the 'checker'

337

512

attribute."""

338

513

self.name = name

339

if config is None:

340

config = {}

514

# adding all client settings

515

for setting, value in settings.iteritems():

516

setattr(self, setting, value)

517

518

if self.enabled:

519

if not hasattr(self, "last_enabled"):

520

self.last_enabled = datetime.datetime.utcnow()

521

if not hasattr(self, "expires"):

522

self.expires = (datetime.datetime.utcnow()

523

+ self.timeout)

524

else:

525

self.last_enabled = None

526

self.expires = None

527

341

528

logger.debug("Creating client %r", self.name)

342

529

# Uppercase and remove spaces from fingerprint for later

343

530

# comparison purposes with return value from the fingerprint()

344

531

# function

345

self.fingerprint = (config["fingerprint"].upper()

346

.replace(" ", ""))

347

532

logger.debug(" Fingerprint: %s", self.fingerprint)

348

if "secret" in config:

349

self.secret = config["secret"].decode("base64")

350

elif "secfile" in config:

351

with open(os.path.expanduser(os.path.expandvars

352

(config["secfile"])),

353

"rb") as secfile:

354

self.secret = secfile.read()

355

else:

356

raise TypeError("No secret or secfile for client %s"

357

% self.name)

358

self.host = config.get("host", "")

359

self.created = datetime.datetime.utcnow()

360

self.enabled = False

361

self.last_approval_request = None

362

self.last_enabled = None

363

self.last_checked_ok = None

364

self.timeout = string_to_delta(config["timeout"])

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

367

self.interval = string_to_delta(config["interval"])

368

self.disable_hook = disable_hook

533

self.created = settings.get("created",

534

datetime.datetime.utcnow())

535

536

# attributes specific for this server instance

369

537

self.checker = None

370

538

self.checker_initiator_tag = None

371

539

self.disable_initiator_tag = None

372

self.expires = None

373

540

self.checker_callback_tag = None

374

self.checker_command = config["checker"]

375

541

self.current_checker_command = None

376

self.last_connect = None

377

self._approved = None

378

self.approved_by_default = config.get("approved_by_default",

379

True)

542

self.approved = None

380

543

self.approvals_pending = 0

381

self.approval_delay = string_to_delta(

382

config["approval_delay"])

383

self.approval_duration = string_to_delta(

384

config["approval_duration"])

385

544

self.changedstate = (multiprocessing_manager

386

545

.Condition(multiprocessing_manager

387

546

.Lock()))

547

self.client_structure = [attr for attr in

548

self.__dict__.iterkeys()

549

if not attr.startswith("_")]

550

self.client_structure.append("client_structure")

551

552

for name, t in inspect.getmembers(type(self),

553

lambda obj:

554

isinstance(obj,

555

property)):

556

if not name.startswith("_"):

557

self.client_structure.append(name)

388

558

559

# Send notice to process children that client state has changed

389

560

def send_changedstate(self):

390

self.changedstate.acquire()

391

self.changedstate.notify_all()

392

self.changedstate.release()

561

with self.changedstate:

562

self.changedstate.notify_all()

393

563

394

564

def enable(self):

395

565

"""Start this client's checker and timeout hooks"""

397

567

# Already enabled

398

568

return

399

569

self.send_changedstate()

400

# Schedule a new checker to be started an 'interval' from now,

401

# and every interval from then on.

402

self.checker_initiator_tag = (gobject.timeout_add

403

(self.interval_milliseconds(),

404

self.start_checker))

405

# Schedule a disable() when 'timeout' has passed

406

570

self.expires = datetime.datetime.utcnow() + self.timeout

407

self.disable_initiator_tag = (gobject.timeout_add

408

(self.timeout_milliseconds(),

409

self.disable))

410

571

self.enabled = True

411

572

self.last_enabled = datetime.datetime.utcnow()

412

# Also start a new checker *right now*.

413

self.start_checker()

573

self.init_checker()

414

574

415

575

def disable(self, quiet=True):

416

576

"""Disable this client."""

428

588

gobject.source_remove(self.checker_initiator_tag)

429

589

self.checker_initiator_tag = None

430

590

self.stop_checker()

431

if self.disable_hook:

432

self.disable_hook(self)

433

591

self.enabled = False

434

592

# Do not run this again if called by a gobject.timeout_add

435

593

return False

436

594

437

595

def __del__(self):

438

self.disable_hook = None

439

596

self.disable()

440

597

598

def init_checker(self):

599

# Schedule a new checker to be started an 'interval' from now,

600

# and every interval from then on.

601

self.checker_initiator_tag = (gobject.timeout_add

602

(self.interval_milliseconds(),

603

self.start_checker))

604

# Schedule a disable() when 'timeout' has passed

605

self.disable_initiator_tag = (gobject.timeout_add

606

(self.timeout_milliseconds(),

607

self.disable))

608

# Also start a new checker *right now*.

609

self.start_checker()

610

441

611

def checker_callback(self, pid, condition, command):

442

612

"""The checker has completed, so take appropriate actions."""

443

613

self.checker_callback_tag = None

444

614

self.checker = None

445

615

if os.WIFEXITED(condition):

446

exitstatus = os.WEXITSTATUS(condition)

447

if exitstatus == 0:

616

self.last_checker_status = os.WEXITSTATUS(condition)

617

if self.last_checker_status == 0:

448

618

logger.info("Checker for %(name)s succeeded",

449

619

vars(self))

450

620

self.checked_ok()

452

622

logger.info("Checker for %(name)s failed",

453

623

vars(self))

454

624

else:

625

self.last_checker_status = -1

455

626

logger.warning("Checker for %(name)s crashed?",

456

627

vars(self))

457

628

458

def checked_ok(self, timeout=None):

459

"""Bump up the timeout for this client.

460

461

This should only be called when the client has been seen,

462

alive and well.

463

"""

629

def checked_ok(self):

630

"""Assert that the client has been seen, alive and well."""

631

self.last_checked_ok = datetime.datetime.utcnow()

632

self.last_checker_status = 0

633

self.bump_timeout()

634

635

def bump_timeout(self, timeout=None):

636

"""Bump up the timeout for this client."""

464

637

if timeout is None:

465

638

timeout = self.timeout

466

self.last_checked_ok = datetime.datetime.utcnow()

467

gobject.source_remove(self.disable_initiator_tag)

468

self.disable_initiator_tag = (gobject.timeout_add

469

(_timedelta_to_milliseconds

470

(timeout), self.disable))

471

self.expires = datetime.datetime.utcnow() + timeout

639

if self.disable_initiator_tag is not None:

640

gobject.source_remove(self.disable_initiator_tag)

641

if getattr(self, "enabled", False):

642

self.disable_initiator_tag = (gobject.timeout_add

643

(timedelta_to_milliseconds

644

(timeout), self.disable))

645

self.expires = datetime.datetime.utcnow() + timeout

472

646

473

647

def need_approval(self):

474

648

self.last_approval_request = datetime.datetime.utcnow()

677

851

# signatures other than "ay".

678

852

if prop._dbus_signature != "ay":

679

853

raise ValueError

680

value = dbus.ByteArray(''.join(unichr(byte)

681

for byte in value))

854

value = dbus.ByteArray(b''.join(chr(byte)

855

for byte in value))

682

856

prop(value)

683

857

684

858

@dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="s",

689

863

690

864

Note: Will not include properties with access="write".

691

865

"""

692

all = {}

866

properties = {}

693

867

for name, prop in self._get_all_dbus_properties():

694

868

if (interface_name

695

869

and interface_name != prop._dbus_interface):

700

874

continue

701

875

value = prop()

702

876

if not hasattr(value, "variant_level"):

703

all[name] = value

877

properties[name] = value

704

878

continue

705

all[name] = type(value)(value, variant_level=

706

value.variant_level+1)

707

return dbus.Dictionary(all, signature="sv")

879

properties[name] = type(value)(value, variant_level=

880

value.variant_level+1)

881

return dbus.Dictionary(properties, signature="sv")

708

882

709

883

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

710

884

out_signature="s",

761

935

return dbus.String(dt.isoformat(),

762

936

variant_level=variant_level)

763

937

938

764

939

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

765

940

.__metaclass__):

766

941

"""Applied to an empty subclass of a D-Bus object, this metaclass

858

1033

attribute.func_closure)))

859

1034

return type.__new__(mcs, name, bases, attr)

860

1035

1036

861

1037

class ClientDBus(Client, DBusObjectWithProperties):

862

1038

"""A Client class using D-Bus

863

1039

872

1048

# dbus.service.Object doesn't use super(), so we can't either.

873

1049

874

1050

def __init__(self, bus = None, *args, **kwargs):

875

self._approvals_pending = 0

876

1051

self.bus = bus

877

1052

Client.__init__(self, *args, **kwargs)

878

1053

# Only now, when this client is initialized, can it show up on

890

1065

variant_level=1):

891

1066

""" Modify a variable so that it's a property which announces

892

1067

its changes to DBus.

893

894

transform_fun: Function that takes a value and transforms it

895

to a D-Bus type.

1068

1069

transform_fun: Function that takes a value and a variant_level

1070

and transforms it to a D-Bus type.

896

1071

dbus_name: D-Bus name of the variable

897

1072

type_func: Function that transform the value before sending it

898

1073

to the D-Bus. Default: no transform

905

1080

type_func(getattr(self, attrname, None))

906

1081

!= type_func(value)):

907

1082

dbus_value = transform_func(type_func(value),

908

variant_level)

1083

variant_level

1084

=variant_level)

909

1085

self.PropertyChanged(dbus.String(dbus_name),

910

1086

dbus_value)

911

1087

setattr(self, attrname, value)

925

1101

checker is not None)

926

1102

last_checked_ok = notifychangeproperty(datetime_to_dbus,

927

1103

"LastCheckedOK")

1104

last_checker_status = notifychangeproperty(dbus.Int16,

1105

"LastCheckerStatus")

928

1106

last_approval_request = notifychangeproperty(

929

1107

datetime_to_dbus, "LastApprovalRequest")

930

1108

approved_by_default = notifychangeproperty(dbus.Boolean,

931

1109

"ApprovedByDefault")

932

approval_delay = notifychangeproperty(dbus.UInt16,

1110

approval_delay = notifychangeproperty(dbus.UInt64,

933

1111

"ApprovalDelay",

934

1112

type_func =

935

_timedelta_to_milliseconds)

1113

timedelta_to_milliseconds)

936

1114

approval_duration = notifychangeproperty(

937

dbus.UInt16, "ApprovalDuration",

938

type_func = _timedelta_to_milliseconds)

1115

dbus.UInt64, "ApprovalDuration",

1116

type_func = timedelta_to_milliseconds)

939

1117

host = notifychangeproperty(dbus.String, "Host")

940

timeout = notifychangeproperty(dbus.UInt16, "Timeout",

1118

timeout = notifychangeproperty(dbus.UInt64, "Timeout",

941

1119

type_func =

942

_timedelta_to_milliseconds)

1120

timedelta_to_milliseconds)

943

1121

extended_timeout = notifychangeproperty(

944

dbus.UInt16, "ExtendedTimeout",

945

type_func = _timedelta_to_milliseconds)

946

interval = notifychangeproperty(dbus.UInt16,

1122

dbus.UInt64, "ExtendedTimeout",

1123

type_func = timedelta_to_milliseconds)

1124

interval = notifychangeproperty(dbus.UInt64,

947

1125

"Interval",

948

1126

type_func =

949

_timedelta_to_milliseconds)

1127

timedelta_to_milliseconds)

950

1128

checker_command = notifychangeproperty(dbus.String, "Checker")

951

1129

952

1130

del notifychangeproperty

994

1172

return r

995

1173

996

1174

def _reset_approved(self):

997

self._approved = None

1175

self.approved = None

998

1176

return False

999

1177

1000

1178

def approve(self, value=True):

1001

1179

self.send_changedstate()

1002

self._approved = value

1003

gobject.timeout_add(_timedelta_to_milliseconds

1180

self.approved = value

1181

gobject.timeout_add(timedelta_to_milliseconds

1004

1182

(self.approval_duration),

1005

1183

self._reset_approved)

1006

1184

1112

1290

access="readwrite")

1113

1291

def ApprovalDuration_dbus_property(self, value=None):

1114

1292

if value is None: # get

1115

return dbus.UInt64(_timedelta_to_milliseconds(

1293

return dbus.UInt64(timedelta_to_milliseconds(

1116

1294

self.approval_duration))

1117

1295

self.approval_duration = datetime.timedelta(0, 0, 0, value)

1118

1296

1132

1310

def Host_dbus_property(self, value=None):

1133

1311

if value is None: # get

1134

1312

return dbus.String(self.host)

1135

self.host = value

1313

self.host = unicode(value)

1136

1314

1137

1315

# Created - property

1138

1316

@dbus_service_property(_interface, signature="s", access="read")

1139

1317

def Created_dbus_property(self):

1140

return dbus.String(datetime_to_dbus(self.created))

1318

return datetime_to_dbus(self.created)

1141

1319

1142

1320

# LastEnabled - property

1143

1321

@dbus_service_property(_interface, signature="s", access="read")

1164

1342

return

1165

1343

return datetime_to_dbus(self.last_checked_ok)

1166

1344

1345

# LastCheckerStatus - property

1346

@dbus_service_property(_interface, signature="n",

1347

access="read")

1348

def LastCheckerStatus_dbus_property(self):

1349

return dbus.Int16(self.last_checker_status)

1350

1167

1351

# Expires - property

1168

1352

@dbus_service_property(_interface, signature="s", access="read")

1169

1353

def Expires_dbus_property(self):

1181

1365

if value is None: # get

1182

1366

return dbus.UInt64(self.timeout_milliseconds())

1183

1367

self.timeout = datetime.timedelta(0, 0, 0, value)

1184

if getattr(self, "disable_initiator_tag", None) is None:

1185

return

1186

1368

# Reschedule timeout

1187

gobject.source_remove(self.disable_initiator_tag)

1188

self.disable_initiator_tag = None

1189

self.expires = None

1190

time_to_die = (self.

1191

_timedelta_to_milliseconds((self

1192

.last_checked_ok

1193

+ self.timeout)

1194

- datetime.datetime

1195

.utcnow()))

1196

if time_to_die <= 0:

1197

# The timeout has passed

1198

self.disable()

1199

else:

1200

self.expires = (datetime.datetime.utcnow()

1201

+ datetime.timedelta(milliseconds =

1202

time_to_die))

1203

self.disable_initiator_tag = (gobject.timeout_add

1204

(time_to_die, self.disable))

1369

if self.enabled:

1370

now = datetime.datetime.utcnow()

1371

time_to_die = timedelta_to_milliseconds(

1372

(self.last_checked_ok + self.timeout) - now)

1373

if time_to_die <= 0:

1374

# The timeout has passed

1375

self.disable()

1376

else:

1377

self.expires = (now +

1378

datetime.timedelta(milliseconds =

1379

time_to_die))

1380

if (getattr(self, "disable_initiator_tag", None)

1381

is None):

1382

return

1383

gobject.source_remove(self.disable_initiator_tag)

1384

self.disable_initiator_tag = (gobject.timeout_add

1385

(time_to_die,

1386

self.disable))

1205

1387

1206

1388

# ExtendedTimeout - property

1207

1389

@dbus_service_property(_interface, signature="t",

1220

1402

self.interval = datetime.timedelta(0, 0, 0, value)

1221

1403

if getattr(self, "checker_initiator_tag", None) is None:

1222

1404

return

1223

# Reschedule checker run

1224

gobject.source_remove(self.checker_initiator_tag)

1225

self.checker_initiator_tag = (gobject.timeout_add

1226

(value, self.start_checker))

1227

self.start_checker() # Start one now, too

1405

if self.enabled:

1406

# Reschedule checker run

1407

gobject.source_remove(self.checker_initiator_tag)

1408

self.checker_initiator_tag = (gobject.timeout_add

1409

(value, self.start_checker))

1410

self.start_checker() # Start one now, too

1228

1411

1229

1412

# Checker - property

1230

1413

@dbus_service_property(_interface, signature="s",

1232

1415

def Checker_dbus_property(self, value=None):

1233

1416

if value is None: # get

1234

1417

return dbus.String(self.checker_command)

1235

self.checker_command = value

1418

self.checker_command = unicode(value)

1236

1419

1237

1420

# CheckerRunning - property

1238

1421

@dbus_service_property(_interface, signature="b",

1267

1450

raise KeyError()

1268

1451

1269

1452

def __getattribute__(self, name):

1270

if(name == '_pipe'):

1453

if name == '_pipe':

1271

1454

return super(ProxyClient, self).__getattribute__(name)

1272

1455

self._pipe.send(('getattr', name))

1273

1456

data = self._pipe.recv()

1280

1463

return func

1281

1464

1282

1465

def __setattr__(self, name, value):

1283

if(name == '_pipe'):

1466

if name == '_pipe':

1284

1467

return super(ProxyClient, self).__setattr__(name, value)

1285

1468

self._pipe.send(('setattr', name, value))

1286

1469

1470

1287

1471

class ClientDBusTransitional(ClientDBus):

1288

1472

__metaclass__ = AlternateDBusNamesMetaclass

1289

1473

1474

1290

1475

class ClientHandler(socketserver.BaseRequestHandler, object):

1291

1476

"""A class to handle client connections.

1292

1477

1374

1559

client.Rejected("Disabled")

1375

1560

return

1376

1561

1377

if client._approved or not client.approval_delay:

1562

if client.approved or not client.approval_delay:

1378

1563

#We are approved or approval is disabled

1379

1564

break

1380

elif client._approved is None:

1565

elif client.approved is None:

1381

1566

logger.info("Client %s needs approval",

1382

1567

client.name)

1383

1568

if self.server.use_dbus:

1397

1582

time = datetime.datetime.now()

1398

1583

client.changedstate.acquire()

1399

1584

(client.changedstate.wait

1400

(float(client._timedelta_to_milliseconds(delay)

1585

(float(client.timedelta_to_milliseconds(delay)

1401

1586

/ 1000)))

1402

1587

client.changedstate.release()

1403

1588

time2 = datetime.datetime.now()

1428

1613

sent_size += sent

1429

1614

1430

1615

logger.info("Sending secret to %s", client.name)

1431

# bump the timeout as if seen

1432

client.checked_ok(client.extended_timeout)

1616

# bump the timeout using extended_timeout

1617

client.bump_timeout(client.extended_timeout)

1433

1618

if self.server.use_dbus:

1434

1619

# Emit D-Bus signal

1435

1620

client.GotSecret()

1502

1687

# Convert the buffer to a Python bytestring

1503

1688

fpr = ctypes.string_at(buf, buf_len.value)

1504

1689

# Convert the bytestring to hexadecimal notation

1505

hex_fpr = ''.join("%02X" % ord(char) for char in fpr)

1690

hex_fpr = binascii.hexlify(fpr).upper()

1506

1691

return hex_fpr

1507

1692

1508

1693

1511

1696

def sub_process_main(self, request, address):

1512

1697

try:

1513

1698

self.finish_request(request, address)

1514

except:

1699

except Exception:

1515

1700

self.handle_error(request, address)

1516

1701

self.close_request(request)

1517

1702

1622

1807

self.enabled = False

1623

1808

self.clients = clients

1624

1809

if self.clients is None:

1625

self.clients = set()

1810

self.clients = {}

1626

1811

self.use_dbus = use_dbus

1627

1812

self.gnutls_priority = gnutls_priority

1628

1813

IPv6_TCPServer.__init__(self, server_address,

1661

1846

for cond, name in

1662

1847

condition_names.iteritems()

1663

1848

if cond & condition)

1664

# error or the other end of multiprocessing.Pipe has closed

1849

# error, or the other end of multiprocessing.Pipe has closed

1665

1850

if condition & (gobject.IO_ERR | condition & gobject.IO_HUP):

1851

# Wait for other process to exit

1666

1852

proc.join()

1667

1853

return False

1668

1854

1674

1860

fpr = request[1]

1675

1861

address = request[2]

1676

1862

1677

for c in self.clients:

1863

for c in self.clients.itervalues():

1678

1864

if c.fingerprint == fpr:

1679

1865

client = c

1680

1866

break

1764

1950

return timevalue

1765

1951

1766

1952

1767

def if_nametoindex(interface):

1768

"""Call the C function if_nametoindex(), or equivalent

1769

1770

Note: This function cannot accept a unicode string."""

1771

global if_nametoindex

1772

try:

1773

if_nametoindex = (ctypes.cdll.LoadLibrary

1774

(ctypes.util.find_library("c"))

1775

.if_nametoindex)

1776

except (OSError, AttributeError):

1777

logger.warning("Doing if_nametoindex the hard way")

1778

def if_nametoindex(interface):

1779

"Get an interface index the hard way, i.e. using fcntl()"

1780

SIOCGIFINDEX = 0x8933 # From /usr/include/linux/sockios.h

1781

with contextlib.closing(socket.socket()) as s:

1782

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1783

struct.pack(str("16s16x"),

1784

interface))

1785

interface_index = struct.unpack(str("I"),

1786

ifreq[16:20])[0]

1787

return interface_index

1788

return if_nametoindex(interface)

1789

1790

1791

1953

def daemon(nochdir = False, noclose = False):

1792

1954

"""See daemon(3). Standard BSD Unix function.

1793

1955

1848

2010

" system bus interface")

1849

2011

parser.add_argument("--no-ipv6", action="store_false",

1850

2012

dest="use_ipv6", help="Do not use IPv6")

2013

parser.add_argument("--no-restore", action="store_false",

2014

dest="restore", help="Do not restore stored"

2015

" state")

2016

parser.add_argument("--statedir", metavar="DIR",

2017

help="Directory to save/restore state in")

2018

1851

2019

options = parser.parse_args()

1852

2020

1853

2021

if options.check:

1866

2034

"use_dbus": "True",

1867

2035

"use_ipv6": "True",

1868

2036

"debuglevel": "",

2037

"restore": "True",

2038

"statedir": "/var/lib/mandos"

1869

2039

}

1870

2040

1871

2041

# Parse config file for server-global settings

1888

2058

# options, if set.

1889

2059

for option in ("interface", "address", "port", "debug",

1890

2060

"priority", "servicename", "configdir",

1891

"use_dbus", "use_ipv6", "debuglevel"):

2061

"use_dbus", "use_ipv6", "debuglevel", "restore",

2062

"statedir"):

1892

2063

value = getattr(options, option)

1893

2064

if value is not None:

1894

2065

server_settings[option] = value

1906

2077

debuglevel = server_settings["debuglevel"]

1907

2078

use_dbus = server_settings["use_dbus"]

1908

2079

use_ipv6 = server_settings["use_ipv6"]

2080

stored_state_path = os.path.join(server_settings["statedir"],

2081

stored_state_file)

2082

2083

if debug:

2084

initlogger(debug, logging.DEBUG)

2085

else:

2086

if not debuglevel:

2087

initlogger(debug)

2088

else:

2089

level = getattr(logging, debuglevel.upper())

2090

initlogger(debug, level)

1909

2091

1910

2092

if server_settings["servicename"] != "Mandos":

1911

2093

syslogger.setFormatter(logging.Formatter

1914

2096

% server_settings["servicename"]))

1915

2097

1916

2098

# Parse config file with clients

1917

client_defaults = { "timeout": "5m",

1918

"extended_timeout": "15m",

1919

"interval": "2m",

1920

"checker": "fping -q -- %%(host)s",

1921

"host": "",

1922

"approval_delay": "0s",

1923

"approval_duration": "1s",

1924

}

1925

client_config = configparser.SafeConfigParser(client_defaults)

2099

client_config = configparser.SafeConfigParser(Client

2100

.client_defaults)

1926

2101

client_config.read(os.path.join(server_settings["configdir"],

1927

2102

"clients.conf"))

1928

2103

1966

2141

if error[0] != errno.EPERM:

1967

2142

raise error

1968

2143

1969

if not debug and not debuglevel:

1970

syslogger.setLevel(logging.WARNING)

1971

console.setLevel(logging.WARNING)

1972

if debuglevel:

1973

level = getattr(logging, debuglevel.upper())

1974

syslogger.setLevel(level)

1975

console.setLevel(level)

1976

1977

2144

if debug:

1978

2145

# Enable all possible GnuTLS debugging

1979

2146

1993

2160

os.dup2(null, sys.stdin.fileno())

1994

2161

if null > 2:

1995

2162

os.close(null)

1996

else:

1997

# No console logging

1998

logger.removeHandler(console)

1999

2163

2000

2164

# Need to fork before connecting to D-Bus

2001

2165

if not debug:

2002

2166

# Close all input and output, do double fork, etc.

2003

2167

daemon()

2004

2168

2169

gobject.threads_init()

2170

2005

2171

global main_loop

2006

2172

# From the Avahi example code

2007

2173

DBusGMainLoop(set_as_default=True )

2021

2187

server_settings["use_dbus"] = False

2022

2188

tcp_server.use_dbus = False

2023

2189

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2024

service = AvahiService(name = server_settings["servicename"],

2025

servicetype = "_mandos._tcp",

2026

protocol = protocol, bus = bus)

2190

service = AvahiServiceToSyslog(name =

2191

server_settings["servicename"],

2192

servicetype = "_mandos._tcp",

2193

protocol = protocol, bus = bus)

2027

2194

if server_settings["interface"]:

2028

2195

service.interface = (if_nametoindex

2029

2196

(str(server_settings["interface"])))

2035

2202

if use_dbus:

2036

2203

client_class = functools.partial(ClientDBusTransitional,

2037

2204

bus = bus)

2038

def client_config_items(config, section):

2039

special_settings = {

2040

"approved_by_default":

2041

lambda: config.getboolean(section,

2042

"approved_by_default"),

2043

}

2044

for name, value in config.items(section):

2205

2206

client_settings = Client.config_parser(client_config)

2207

old_client_settings = {}

2208

clients_data = {}

2209

2210

# Get client data and settings from last running state.

2211

if server_settings["restore"]:

2212

try:

2213

with open(stored_state_path, "rb") as stored_state:

2214

clients_data, old_client_settings = (pickle.load

2215

(stored_state))

2216

os.remove(stored_state_path)

2217

except IOError as e:

2218

logger.warning("Could not load persistent state: {0}"

2219

.format(e))

2220

if e.errno != errno.ENOENT:

2221

raise

2222

except EOFError as e:

2223

logger.warning("Could not load persistent state: "

2224

"EOFError: {0}".format(e))

2225

2226

with PGPEngine() as pgp:

2227

for client_name, client in clients_data.iteritems():

2228

# Decide which value to use after restoring saved state.

2229

# We have three different values: Old config file,

2230

# new config file, and saved state.

2231

# New config value takes precedence if it differs from old

2232

# config value, otherwise use saved state.

2233

for name, value in client_settings[client_name].items():

2234

try:

2235

# For each value in new config, check if it

2236

# differs from the old config value (Except for

2237

# the "secret" attribute)

2238

if (name != "secret" and

2239

value != old_client_settings[client_name]

2240

[name]):

2241

client[name] = value

2242

except KeyError:

2243

pass

2244

2245

# Clients who has passed its expire date can still be

2246

# enabled if its last checker was successful. Clients

2247

# whose checker succeeded before we stored its state is

2248

# assumed to have successfully run all checkers during

2249

# downtime.

2250

if client["enabled"]:

2251

if datetime.datetime.utcnow() >= client["expires"]:

2252

if not client["last_checked_ok"]:

2253

logger.warning(

2254

"disabling client {0} - Client never "

2255

"performed a successful checker"

2256

.format(client_name))

2257

client["enabled"] = False

2258

elif client["last_checker_status"] != 0:

2259

logger.warning(

2260

"disabling client {0} - Client "

2261

"last checker failed with error code {1}"

2262

.format(client_name,

2263

client["last_checker_status"]))

2264

client["enabled"] = False

2265

else:

2266

client["expires"] = (datetime.datetime

2267

.utcnow()

2268

+ client["timeout"])

2269

logger.debug("Last checker succeeded,"

2270

" keeping {0} enabled"

2271

.format(client_name))

2045

2272

try:

2046

yield (name, special_settings[name]())

2047

except KeyError:

2048

yield (name, value)

2049

2050

tcp_server.clients.update(set(

2051

client_class(name = section,

2052

config= dict(client_config_items(

2053

client_config, section)))

2054

for section in client_config.sections()))

2273

client["secret"] = (

2274

pgp.decrypt(client["encrypted_secret"],

2275

client_settings[client_name]

2276

["secret"]))

2277

except PGPError:

2278

# If decryption fails, we use secret from new settings

2279

logger.debug("Failed to decrypt {0} old secret"

2280

.format(client_name))

2281

client["secret"] = (

2282

client_settings[client_name]["secret"])

2283

2284

2285

# Add/remove clients based on new changes made to config

2286

for client_name in (set(old_client_settings)

2287

- set(client_settings)):

2288

del clients_data[client_name]

2289

for client_name in (set(client_settings)

2290

- set(old_client_settings)):

2291

clients_data[client_name] = client_settings[client_name]

2292

2293

# Create all client objects

2294

for client_name, client in clients_data.iteritems():

2295

tcp_server.clients[client_name] = client_class(

2296

name = client_name, settings = client)

2297

2055

2298

if not tcp_server.clients:

2056

2299

logger.warning("No clients defined")

2057

2300

2068

2311

# "pidfile" was never created

2069

2312

pass

2070

2313

del pidfilename

2071

2072

2314

signal.signal(signal.SIGINT, signal.SIG_IGN)

2073

2315

2074

2316

signal.signal(signal.SIGHUP, lambda signum, frame: sys.exit())

2100

2342

def GetAllClients(self):

2101

2343

"D-Bus method"

2102

2344

return dbus.Array(c.dbus_object_path

2103

for c in tcp_server.clients)

2345

for c in

2346

tcp_server.clients.itervalues())

2104

2347

2105

2348

@dbus.service.method(_interface,

2106

2349

out_signature="a{oa{sv}}")

2108

2351

"D-Bus method"

2109

2352

return dbus.Dictionary(

2110

2353

((c.dbus_object_path, c.GetAll(""))

2111

for c in tcp_server.clients),

2354

for c in tcp_server.clients.itervalues()),

2112

2355

signature="oa{sv}")

2113

2356

2114

2357

@dbus.service.method(_interface, in_signature="o")

2115

2358

def RemoveClient(self, object_path):

2116

2359

"D-Bus method"

2117

for c in tcp_server.clients:

2360

for c in tcp_server.clients.itervalues():

2118

2361

if c.dbus_object_path == object_path:

2119

tcp_server.clients.remove(c)

2362

del tcp_server.clients[c.name]

2120

2363

c.remove_from_connection()

2121

2364

# Don't signal anything except ClientRemoved

2122

2365

c.disable(quiet=True)

2136

2379

service.cleanup()

2137

2380

2138

2381

multiprocessing.active_children()

2382

if not (tcp_server.clients or client_settings):

2383

return

2384

2385

# Store client before exiting. Secrets are encrypted with key

2386

# based on what config file has. If config file is

2387

# removed/edited, old secret will thus be unrecovable.

2388

clients = {}

2389

with PGPEngine() as pgp:

2390

for client in tcp_server.clients.itervalues():

2391

key = client_settings[client.name]["secret"]

2392

client.encrypted_secret = pgp.encrypt(client.secret,

2393

key)

2394

client_dict = {}

2395

2396

# A list of attributes that can not be pickled

2397

# + secret.

2398

exclude = set(("bus", "changedstate", "secret",

2399

"checker"))

2400

for name, typ in (inspect.getmembers

2401

(dbus.service.Object)):

2402

exclude.add(name)

2403

2404

client_dict["encrypted_secret"] = (client

2405

.encrypted_secret)

2406

for attr in client.client_structure:

2407

if attr not in exclude:

2408

client_dict[attr] = getattr(client, attr)

2409

2410

clients[client.name] = client_dict

2411

del client_settings[client.name]["secret"]

2412

2413

try:

2414

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2415

prefix="clients-",

2416

dir=os.path.dirname

2417

(stored_state_path))

2418

with os.fdopen(tempfd, "wb") as stored_state:

2419

pickle.dump((clients, client_settings), stored_state)

2420

os.rename(tempname, stored_state_path)

2421

except (IOError, OSError) as e:

2422

logger.warning("Could not save persistent state: {0}"

2423

.format(e))

2424

if not debug:

2425

try:

2426

os.remove(tempname)

2427

except NameError:

2428

pass

2429

if e.errno not in set((errno.ENOENT, errno.EACCES,

2430

errno.EEXIST)):

2431

raise e

2432

2433

# Delete all clients, and settings from config

2139

2434

while tcp_server.clients:

2140

client = tcp_server.clients.pop()

2435

name, client = tcp_server.clients.popitem()

2141

2436

if use_dbus:

2142

2437

client.remove_from_connection()

2143

client.disable_hook = None

2144

2438

# Don't signal anything except ClientRemoved

2145

2439

client.disable(quiet=True)

2146

2440

if use_dbus:

2148

2442

mandos_dbus_service.ClientRemoved(client

2149

2443

.dbus_object_path,

2150

2444

client.name)

2445

client_settings.clear()

2151

2446

2152

2447

atexit.register(cleanup)

2153

2448

2154

for client in tcp_server.clients:

2449

for client in tcp_server.clients.itervalues():

2155

2450

if use_dbus:

2156

2451

# Emit D-Bus signal

2157

2452

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2158

client.enable()

2453

# Need to initiate checking of clients

2454

if client.enabled:

2455

client.init_checker()

2159

2456

2160

2457

tcp_server.enable()

2161

2458

tcp_server.server_activate()

2201

2498

# Must run before the D-Bus bus name gets deregistered

2202

2499

cleanup()

2203

2500

2204

2205

2501

if __name__ == '__main__':

2206

2502

main()