/mandos/trunk : revision 546

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

88

version = "1.4.1"

89

stored_state_file = "clients.pickle"

87

90

88

91

logger = logging.getLogger()

89

92

syslogger = (logging.handlers.SysLogHandler

90

93

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

91

94

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

92

syslogger.setFormatter(logging.Formatter

93

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

94

' %(message)s'))

95

logger.addHandler(syslogger)

96

97

console = logging.StreamHandler()

98

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

99

' [%(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

103

210

104

211

105

212

class AvahiError(Exception):

222

329

try:

223

330

self.group.Free()

224

331

except (dbus.exceptions.UnknownMethodException,

225

dbus.exceptions.DBusException) as e:

332

dbus.exceptions.DBusException):

226

333

pass

227

334

self.group = None

228

335

self.remove()

272

379

% self.name))

273

380

return ret

274

381

275

def _timedelta_to_milliseconds(td):

382

def timedelta_to_milliseconds(td):

276

383

"Convert a datetime.timedelta() to milliseconds"

277

384

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

278

385

+ (td.seconds * 1000)

282

389

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

283

390

284

391

Attributes:

285

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

392

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

286

393

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

287

394

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

288

395

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

295

402

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

296

403

checker_initiator_tag: a gobject event source tag, or None

297

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

298

407

current_checker_command: string; current running checker_command

299

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

300

408

disable_initiator_tag: a gobject event source tag, or None

301

409

enabled: bool()

302

410

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

305

413

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

306

414

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

307

415

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

308

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, or None.

419

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

309

420

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

310

421

D-Bus identifiers

311

422

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

321

432

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

322

433

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

323

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

}

324

445

325

446

def timeout_milliseconds(self):

326

447

"Return the 'timeout' attribute in milliseconds"

327

return _timedelta_to_milliseconds(self.timeout)

448

return timedelta_to_milliseconds(self.timeout)

328

449

329

450

def extended_timeout_milliseconds(self):

330

451

"Return the 'extended_timeout' attribute in milliseconds"

331

return _timedelta_to_milliseconds(self.extended_timeout)

452

return timedelta_to_milliseconds(self.extended_timeout)

332

453

333

454

def interval_milliseconds(self):

334

455

"Return the 'interval' attribute in milliseconds"

335

return _timedelta_to_milliseconds(self.interval)

456

return timedelta_to_milliseconds(self.interval)

336

457

337

458

def approval_delay_milliseconds(self):

338

return _timedelta_to_milliseconds(self.approval_delay)

339

340

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"] = None

505

506

return settings

507

508

509

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

341

510

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

342

511

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

343

512

attribute."""

344

513

self.name = name

345

if config is None:

346

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

347

528

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

348

529

# Uppercase and remove spaces from fingerprint for later

349

530

# comparison purposes with return value from the fingerprint()

350

531

# function

351

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

352

.replace(" ", ""))

353

532

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

354

if "secret" in config:

355

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

356

elif "secfile" in config:

357

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

358

(config["secfile"])),

359

"rb") as secfile:

360

self.secret = secfile.read()

361

else:

362

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

363

% self.name)

364

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

365

self.created = datetime.datetime.utcnow()

366

self.enabled = False

367

self.last_approval_request = None

368

self.last_enabled = None

369

self.last_checked_ok = None

370

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

371

self.extended_timeout = string_to_delta(config

372

["extended_timeout"])

373

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

374

self.disable_hook = disable_hook

533

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

534

datetime.datetime.utcnow())

535

536

# attributes specific for this server instance

375

537

self.checker = None

376

538

self.checker_initiator_tag = None

377

539

self.disable_initiator_tag = None

378

self.expires = None

379

540

self.checker_callback_tag = None

380

self.checker_command = config["checker"]

381

541

self.current_checker_command = None

382

self.last_connect = None

383

self._approved = None

384

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

385

True)

542

self.approved = None

386

543

self.approvals_pending = 0

387

self.approval_delay = string_to_delta(

388

config["approval_delay"])

389

self.approval_duration = string_to_delta(

390

config["approval_duration"])

391

544

self.changedstate = (multiprocessing_manager

392

545

.Condition(multiprocessing_manager

393

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)

394

558

559

# Send notice to process children that client state has changed

395

560

def send_changedstate(self):

396

self.changedstate.acquire()

397

self.changedstate.notify_all()

398

self.changedstate.release()

561

with self.changedstate:

562

self.changedstate.notify_all()

399

563

400

564

def enable(self):

401

565

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

403

567

# Already enabled

404

568

return

405

569

self.send_changedstate()

406

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

407

# and every interval from then on.

408

self.checker_initiator_tag = (gobject.timeout_add

409

(self.interval_milliseconds(),

410

self.start_checker))

411

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

412

570

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

413

self.disable_initiator_tag = (gobject.timeout_add

414

(self.timeout_milliseconds(),

415

self.disable))

416

571

self.enabled = True

417

572

self.last_enabled = datetime.datetime.utcnow()

418

# Also start a new checker *right now*.

419

self.start_checker()

573

self.init_checker()

420

574

421

575

def disable(self, quiet=True):

422

576

"""Disable this client."""

434

588

gobject.source_remove(self.checker_initiator_tag)

435

589

self.checker_initiator_tag = None

436

590

self.stop_checker()

437

if self.disable_hook:

438

self.disable_hook(self)

439

591

self.enabled = False

440

592

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

441

593

return False

442

594

443

595

def __del__(self):

444

self.disable_hook = None

445

596

self.disable()

446

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

447

611

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

448

612

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

449

613

self.checker_callback_tag = None

450

614

self.checker = None

451

615

if os.WIFEXITED(condition):

452

exitstatus = os.WEXITSTATUS(condition)

453

if exitstatus == 0:

616

self.last_checker_status = os.WEXITSTATUS(condition)

617

if self.last_checker_status == 0:

454

618

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

455

619

vars(self))

456

620

self.checked_ok()

458

622

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

459

623

vars(self))

460

624

else:

625

self.last_checker_status = -1

461

626

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

462

627

vars(self))

463

628

474

639

gobject.source_remove(self.disable_initiator_tag)

475

640

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

476

641

self.disable_initiator_tag = (gobject.timeout_add

477

(_timedelta_to_milliseconds

642

(timedelta_to_milliseconds

478

643

(timeout), self.disable))

479

644

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

480

645

685

850

# signatures other than "ay".

686

851

if prop._dbus_signature != "ay":

687

852

raise ValueError

688

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

689

for byte in value))

853

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

854

for byte in value))

690

855

prop(value)

691

856

692

857

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

697

862

698

863

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

699

864

"""

700

all = {}

865

properties = {}

701

866

for name, prop in self._get_all_dbus_properties():

702

867

if (interface_name

703

868

and interface_name != prop._dbus_interface):

708

873

continue

709

874

value = prop()

710

875

if not hasattr(value, "variant_level"):

711

all[name] = value

876

properties[name] = value

712

877

continue

713

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

714

value.variant_level+1)

715

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

878

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

879

value.variant_level+1)

880

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

716

881

717

882

@dbus.service.method(dbus.INTROSPECTABLE_IFACE,

718

883

out_signature="s",

769

934

return dbus.String(dt.isoformat(),

770

935

variant_level=variant_level)

771

936

937

772

938

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

773

939

.__metaclass__):

774

940

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

866

1032

attribute.func_closure)))

867

1033

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

868

1034

1035

869

1036

class ClientDBus(Client, DBusObjectWithProperties):

870

1037

"""A Client class using D-Bus

871

1038

880

1047

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

881

1048

882

1049

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

883

self._approvals_pending = 0

884

1050

self.bus = bus

885

1051

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

1052

self._approvals_pending = 0

1053

1054

self._approvals_pending = 0

886

1055

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

887

1056

# the D-Bus

888

1057

client_object_name = unicode(self.name).translate(

898

1067

variant_level=1):

899

1068

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

900

1069

its changes to DBus.

901

1070

902

1071

transform_fun: Function that takes a value and a variant_level

903

1072

and transforms it to a D-Bus type.

904

1073

dbus_name: D-Bus name of the variable

938

1107

datetime_to_dbus, "LastApprovalRequest")

939

1108

approved_by_default = notifychangeproperty(dbus.Boolean,

940

1109

"ApprovedByDefault")

941

approval_delay = notifychangeproperty(dbus.UInt16,

1110

approval_delay = notifychangeproperty(dbus.UInt64,

942

1111

"ApprovalDelay",

943

1112

type_func =

944

_timedelta_to_milliseconds)

1113

timedelta_to_milliseconds)

945

1114

approval_duration = notifychangeproperty(

946

dbus.UInt16, "ApprovalDuration",

947

type_func = _timedelta_to_milliseconds)

1115

dbus.UInt64, "ApprovalDuration",

1116

type_func = timedelta_to_milliseconds)

948

1117

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

949

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

1118

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

950

1119

type_func =

951

_timedelta_to_milliseconds)

1120

timedelta_to_milliseconds)

952

1121

extended_timeout = notifychangeproperty(

953

dbus.UInt16, "ExtendedTimeout",

954

type_func = _timedelta_to_milliseconds)

955

interval = notifychangeproperty(dbus.UInt16,

1122

dbus.UInt64, "ExtendedTimeout",

1123

type_func = timedelta_to_milliseconds)

1124

interval = notifychangeproperty(dbus.UInt64,

956

1125

"Interval",

957

1126

type_func =

958

_timedelta_to_milliseconds)

1127

timedelta_to_milliseconds)

959

1128

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

960

1129

961

1130

del notifychangeproperty

1003

1172

return r

1004

1173

1005

1174

def _reset_approved(self):

1006

self._approved = None

1175

self.approved = None

1007

1176

return False

1008

1177

1009

1178

def approve(self, value=True):

1010

1179

self.send_changedstate()

1011

self._approved = value

1012

gobject.timeout_add(_timedelta_to_milliseconds

1180

self.approved = value

1181

gobject.timeout_add(timedelta_to_milliseconds

1013

1182

(self.approval_duration),

1014

1183

self._reset_approved)

1015

1184

1058

1227

"D-Bus signal"

1059

1228

return self.need_approval()

1060

1229

1230

# NeRwequest - signal

1231

@dbus.service.signal(_interface, signature="s")

1232

def NewRequest(self, ip):

1233

"""D-Bus signal

1234

Is sent after a client request a password.

1235

"""

1236

pass

1237

1061

1238

## Methods

1062

1239

1063

1240

# Approve - method

1121

1298

access="readwrite")

1122

1299

def ApprovalDuration_dbus_property(self, value=None):

1123

1300

if value is None: # get

1124

return dbus.UInt64(_timedelta_to_milliseconds(

1301

return dbus.UInt64(timedelta_to_milliseconds(

1125

1302

self.approval_duration))

1126

1303

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

1127

1304

1141

1318

def Host_dbus_property(self, value=None):

1142

1319

if value is None: # get

1143

1320

return dbus.String(self.host)

1144

self.host = value

1321

self.host = unicode(value)

1145

1322

1146

1323

# Created - property

1147

1324

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

1148

1325

def Created_dbus_property(self):

1149

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

1326

return datetime_to_dbus(self.created)

1150

1327

1151

1328

# LastEnabled - property

1152

1329

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

1190

1367

if value is None: # get

1191

1368

return dbus.UInt64(self.timeout_milliseconds())

1192

1369

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

1193

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

1194

return

1195

1370

# Reschedule timeout

1196

gobject.source_remove(self.disable_initiator_tag)

1197

self.disable_initiator_tag = None

1198

self.expires = None

1199

time_to_die = _timedelta_to_milliseconds((self

1200

.last_checked_ok

1201

+ self.timeout)

1202

- datetime.datetime

1203

.utcnow())

1204

if time_to_die <= 0:

1205

# The timeout has passed

1206

self.disable()

1207

else:

1208

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

1209

+ datetime.timedelta(milliseconds =

1210

time_to_die))

1211

self.disable_initiator_tag = (gobject.timeout_add

1212

(time_to_die, self.disable))

1371

if self.enabled:

1372

now = datetime.datetime.utcnow()

1373

time_to_die = timedelta_to_milliseconds(

1374

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

1375

if time_to_die <= 0:

1376

# The timeout has passed

1377

self.disable()

1378

else:

1379

self.expires = (now +

1380

datetime.timedelta(milliseconds =

1381

time_to_die))

1382

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

1383

is None):

1384

return

1385

gobject.source_remove(self.disable_initiator_tag)

1386

self.disable_initiator_tag = (gobject.timeout_add

1387

(time_to_die,

1388

self.disable))

1213

1389

1214

1390

# ExtendedTimeout - property

1215

1391

@dbus_service_property(_interface, signature="t",

1228

1404

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

1229

1405

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

1230

1406

return

1231

# Reschedule checker run

1232

gobject.source_remove(self.checker_initiator_tag)

1233

self.checker_initiator_tag = (gobject.timeout_add

1234

(value, self.start_checker))

1235

self.start_checker() # Start one now, too

1407

if self.enabled:

1408

# Reschedule checker run

1409

gobject.source_remove(self.checker_initiator_tag)

1410

self.checker_initiator_tag = (gobject.timeout_add

1411

(value, self.start_checker))

1412

self.start_checker() # Start one now, too

1236

1413

1237

1414

# Checker - property

1238

1415

@dbus_service_property(_interface, signature="s",

1240

1417

def Checker_dbus_property(self, value=None):

1241

1418

if value is None: # get

1242

1419

return dbus.String(self.checker_command)

1243

self.checker_command = value

1420

self.checker_command = unicode(value)

1244

1421

1245

1422

# CheckerRunning - property

1246

1423

@dbus_service_property(_interface, signature="b",

1275

1452

raise KeyError()

1276

1453

1277

1454

def __getattribute__(self, name):

1278

if(name == '_pipe'):

1455

if name == '_pipe':

1279

1456

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

1280

1457

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

1281

1458

data = self._pipe.recv()

1288

1465

return func

1289

1466

1290

1467

def __setattr__(self, name, value):

1291

if(name == '_pipe'):

1468

if name == '_pipe':

1292

1469

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

1293

1470

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

1294

1471

1472

1295

1473

class ClientDBusTransitional(ClientDBus):

1296

1474

__metaclass__ = AlternateDBusNamesMetaclass

1297

1475

1476

1298

1477

class ClientHandler(socketserver.BaseRequestHandler, object):

1299

1478

"""A class to handle client connections.

1300

1479

1368

1547

except KeyError:

1369

1548

return

1370

1549

1550

if self.server.use_dbus:

1551

# Emit D-Bus signal

1552

client.NewRequest(str(self.client_address))

1553

1371

1554

if client.approval_delay:

1372

1555

delay = client.approval_delay

1373

1556

client.approvals_pending += 1

1382

1565

client.Rejected("Disabled")

1383

1566

return

1384

1567

1385

if client._approved or not client.approval_delay:

1568

if client.approved or not client.approval_delay:

1386

1569

#We are approved or approval is disabled

1387

1570

break

1388

elif client._approved is None:

1571

elif client.approved is None:

1389

1572

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

1390

1573

client.name)

1391

1574

if self.server.use_dbus:

1405

1588

time = datetime.datetime.now()

1406

1589

client.changedstate.acquire()

1407

1590

(client.changedstate.wait

1408

(float(client._timedelta_to_milliseconds(delay)

1591

(float(client.timedelta_to_milliseconds(delay)

1409

1592

/ 1000)))

1410

1593

client.changedstate.release()

1411

1594

time2 = datetime.datetime.now()

1510

1693

# Convert the buffer to a Python bytestring

1511

1694

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

1512

1695

# Convert the bytestring to hexadecimal notation

1513

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

1696

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

1514

1697

return hex_fpr

1515

1698

1516

1699

1519

1702

def sub_process_main(self, request, address):

1520

1703

try:

1521

1704

self.finish_request(request, address)

1522

except:

1705

except Exception:

1523

1706

self.handle_error(request, address)

1524

1707

self.close_request(request)

1525

1708

1630

1813

self.enabled = False

1631

1814

self.clients = clients

1632

1815

if self.clients is None:

1633

self.clients = set()

1816

self.clients = {}

1634

1817

self.use_dbus = use_dbus

1635

1818

self.gnutls_priority = gnutls_priority

1636

1819

IPv6_TCPServer.__init__(self, server_address,

1683

1866

fpr = request[1]

1684

1867

address = request[2]

1685

1868

1686

for c in self.clients:

1869

for c in self.clients.itervalues():

1687

1870

if c.fingerprint == fpr:

1688

1871

client = c

1689

1872

break

1773

1956

return timevalue

1774

1957

1775

1958

1776

def if_nametoindex(interface):

1777

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

1778

1779

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

1780

global if_nametoindex

1781

try:

1782

if_nametoindex = (ctypes.cdll.LoadLibrary

1783

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

1784

.if_nametoindex)

1785

except (OSError, AttributeError):

1786

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

1787

def if_nametoindex(interface):

1788

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

1789

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

1790

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

1791

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1792

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

1793

interface))

1794

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

1795

ifreq[16:20])[0]

1796

return interface_index

1797

return if_nametoindex(interface)

1798

1799

1800

1959

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

1801

1960

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

1802

1961

1857

2016

" system bus interface")

1858

2017

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

1859

2018

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

2019

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

2020

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

2021

" state")

2022

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

2023

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

2024

1860

2025

options = parser.parse_args()

1861

2026

1862

2027

if options.check:

1875

2040

"use_dbus": "True",

1876

2041

"use_ipv6": "True",

1877

2042

"debuglevel": "",

2043

"restore": "True",

2044

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

1878

2045

}

1879

2046

1880

2047

# Parse config file for server-global settings

1897

2064

# options, if set.

1898

2065

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

1899

2066

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

1900

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

2067

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

2068

"statedir"):

1901

2069

value = getattr(options, option)

1902

2070

if value is not None:

1903

2071

server_settings[option] = value

1915

2083

debuglevel = server_settings["debuglevel"]

1916

2084

use_dbus = server_settings["use_dbus"]

1917

2085

use_ipv6 = server_settings["use_ipv6"]

2086

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

2087

stored_state_file)

2088

2089

if debug:

2090

initlogger(debug, logging.DEBUG)

2091

else:

2092

if not debuglevel:

2093

initlogger(debug)

2094

else:

2095

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

2096

initlogger(debug, level)

1918

2097

1919

2098

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

1920

2099

syslogger.setFormatter(logging.Formatter

1923

2102

% server_settings["servicename"]))

1924

2103

1925

2104

# Parse config file with clients

1926

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

1927

"extended_timeout": "15m",

1928

"interval": "2m",

1929

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

1930

"host": "",

1931

"approval_delay": "0s",

1932

"approval_duration": "1s",

1933

}

1934

client_config = configparser.SafeConfigParser(client_defaults)

2105

client_config = configparser.SafeConfigParser(Client

2106

.client_defaults)

1935

2107

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

1936

2108

"clients.conf"))

1937

2109

1975

2147

if error[0] != errno.EPERM:

1976

2148

raise error

1977

2149

1978

if not debug and not debuglevel:

1979

logger.setLevel(logging.WARNING)

1980

if debuglevel:

1981

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

1982

logger.setLevel(level)

1983

1984

2150

if debug:

1985

logger.setLevel(logging.DEBUG)

1986

2151

# Enable all possible GnuTLS debugging

1987

2152

1988

2153

# "Use a log level over 10 to enable all debugging options."

2001

2166

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

2002

2167

if null > 2:

2003

2168

os.close(null)

2004

else:

2005

# No console logging

2006

logger.removeHandler(console)

2007

2169

2008

2170

# Need to fork before connecting to D-Bus

2009

2171

if not debug:

2010

2172

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

2011

2173

daemon()

2012

2174

2175

gobject.threads_init()

2176

2013

2177

global main_loop

2014

2178

# From the Avahi example code

2015

2179

DBusGMainLoop(set_as_default=True )

2044

2208

if use_dbus:

2045

2209

client_class = functools.partial(ClientDBusTransitional,

2046

2210

bus = bus)

2047

def client_config_items(config, section):

2048

special_settings = {

2049

"approved_by_default":

2050

lambda: config.getboolean(section,

2051

"approved_by_default"),

2052

}

2053

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

2211

2212

client_settings = Client.config_parser(client_config)

2213

old_client_settings = {}

2214

clients_data = {}

2215

2216

# Get client data and settings from last running state.

2217

if server_settings["restore"]:

2218

try:

2219

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

2220

clients_data, old_client_settings = (pickle.load

2221

(stored_state))

2222

os.remove(stored_state_path)

2223

except IOError as e:

2224

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

2225

.format(e))

2226

if e.errno != errno.ENOENT:

2227

raise

2228

except EOFError as e:

2229

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

2230

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

2231

2232

with PGPEngine() as pgp:

2233

for client_name, client in clients_data.iteritems():

2234

# Decide which value to use after restoring saved state.

2235

# We have three different values: Old config file,

2236

# new config file, and saved state.

2237

# New config value takes precedence if it differs from old

2238

# config value, otherwise use saved state.

2239

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

2240

try:

2241

# For each value in new config, check if it

2242

# differs from the old config value (Except for

2243

# the "secret" attribute)

2244

if (name != "secret" and

2245

value != old_client_settings[client_name]

2246

[name]):

2247

client[name] = value

2248

except KeyError:

2249

pass

2250

2251

# Clients who has passed its expire date can still be

2252

# enabled if its last checker was successful. Clients

2253

# whose checker failed before we stored its state is

2254

# assumed to have failed all checkers during downtime.

2255

if client["enabled"]:

2256

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

2257

if not client["last_checked_ok"]:

2258

logger.warning(

2259

"disabling client {0} - Client never "

2260

"performed a successfull checker"

2261

.format(client["name"]))

2262

client["enabled"] = False

2263

elif client["last_checker_status"] != 0:

2264

logger.warning(

2265

"disabling client {0} - Client "

2266

"last checker failed with error code {1}"

2267

.format(client["name"],

2268

client["last_checker_status"]))

2269

client["enabled"] = False

2270

else:

2271

client["expires"] = (datetime.datetime

2272

.utcnow()

2273

+ client["timeout"])

2274

logger.debug("Last checker succeeded,"

2275

" keeping {0} enabled"

2276

.format(client["name"]))

2054

2277

try:

2055

yield (name, special_settings[name]())

2056

except KeyError:

2057

yield (name, value)

2058

2059

tcp_server.clients.update(set(

2060

client_class(name = section,

2061

config= dict(client_config_items(

2062

client_config, section)))

2063

for section in client_config.sections()))

2278

client["secret"] = (

2279

pgp.decrypt(client["encrypted_secret"],

2280

client_settings[client_name]

2281

["secret"]))

2282

except PGPError:

2283

# If decryption fails, we use secret from new settings

2284

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

2285

.format(client_name))

2286

client["secret"] = (

2287

client_settings[client_name]["secret"])

2288

2289

2290

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

2291

for client_name in (set(old_client_settings)

2292

- set(client_settings)):

2293

del clients_data[client_name]

2294

for client_name in (set(client_settings)

2295

- set(old_client_settings)):

2296

clients_data[client_name] = client_settings[client_name]

2297

2298

# Create clients all clients

2299

for client_name, client in clients_data.iteritems():

2300

tcp_server.clients[client_name] = client_class(

2301

name = client_name, settings = client)

2302

2064

2303

if not tcp_server.clients:

2065

2304

logger.warning("No clients defined")

2066

2305

2077

2316

# "pidfile" was never created

2078

2317

pass

2079

2318

del pidfilename

2080

2081

2319

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

2082

2320

2083

2321

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

2109

2347

def GetAllClients(self):

2110

2348

"D-Bus method"

2111

2349

return dbus.Array(c.dbus_object_path

2112

for c in tcp_server.clients)

2350

for c in

2351

tcp_server.clients.itervalues())

2113

2352

2114

2353

@dbus.service.method(_interface,

2115

2354

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

2117

2356

"D-Bus method"

2118

2357

return dbus.Dictionary(

2119

2358

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

2120

for c in tcp_server.clients),

2359

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

2121

2360

signature="oa{sv}")

2122

2361

2123

2362

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

2124

2363

def RemoveClient(self, object_path):

2125

2364

"D-Bus method"

2126

for c in tcp_server.clients:

2365

for c in tcp_server.clients.itervalues():

2127

2366

if c.dbus_object_path == object_path:

2128

tcp_server.clients.remove(c)

2367

del tcp_server.clients[c.name]

2129

2368

c.remove_from_connection()

2130

2369

# Don't signal anything except ClientRemoved

2131

2370

c.disable(quiet=True)

2145

2384

service.cleanup()

2146

2385

2147

2386

multiprocessing.active_children()

2387

if not (tcp_server.clients or client_settings):

2388

return

2389

2390

# Store client before exiting. Secrets are encrypted with key

2391

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

2392

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

2393

clients = {}

2394

with PGPEngine() as pgp:

2395

for client in tcp_server.clients.itervalues():

2396

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

2397

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

2398

key)

2399

client_dict = {}

2400

2401

# A list of attributes that can not be pickled

2402

# + secret.

2403

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

2404

"checker"))

2405

for name, typ in (inspect.getmembers

2406

(dbus.service.Object)):

2407

exclude.add(name)

2408

2409

client_dict["encrypted_secret"] = (client

2410

.encrypted_secret)

2411

for attr in client.client_structure:

2412

if attr not in exclude:

2413

client_dict[attr] = getattr(client, attr)

2414

2415

clients[client.name] = client_dict

2416

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

2417

2418

try:

2419

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

2420

prefix="clients-",

2421

dir=os.path.dirname

2422

(stored_state_path))

2423

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

2424

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

2425

os.rename(tempname, stored_state_path)

2426

except (IOError, OSError) as e:

2427

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

2428

.format(e))

2429

if not debug:

2430

try:

2431

os.remove(tempname)

2432

except NameError:

2433

pass

2434

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

2435

errno.EEXIST)):

2436

raise e

2437

2438

# Delete all clients, and settings from config

2148

2439

while tcp_server.clients:

2149

client = tcp_server.clients.pop()

2440

name, client = tcp_server.clients.popitem()

2150

2441

if use_dbus:

2151

2442

client.remove_from_connection()

2152

client.disable_hook = None

2153

2443

# Don't signal anything except ClientRemoved

2154

2444

client.disable(quiet=True)

2155

2445

if use_dbus:

2157

2447

mandos_dbus_service.ClientRemoved(client

2158

2448

.dbus_object_path,

2159

2449

client.name)

2450

client_settings.clear()

2160

2451

2161

2452

atexit.register(cleanup)

2162

2453

2163

for client in tcp_server.clients:

2454

for client in tcp_server.clients.itervalues():

2164

2455

if use_dbus:

2165

2456

# Emit D-Bus signal

2166

2457

mandos_dbus_service.ClientAdded(client.dbus_object_path)

2167

client.enable()

2458

# Need to initiate checking of clients

2459

if client.enabled:

2460

client.init_checker()

2168

2461

2169

2462

tcp_server.enable()

2170

2463

tcp_server.server_activate()

2210

2503

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

2211

2504

cleanup()

2212

2505

2213

2214

2506

if __name__ == '__main__':

2215

2507

main()