/mandos/release : revision 237.16.24

28

# along with this program. If not, see

29

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

30

#

31

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

31

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

32

#

33

34

from __future__ import (division, absolute_import, print_function,

62

import functools

63

import cPickle as pickle

64

import multiprocessing

65

import types

65

66

67

import dbus

67

68

import dbus.service

82

83

SO_BINDTODEVICE = None

83

84

85

version = "1.3.0"

86

version = "1.4.1"

86

87

88

#logger = logging.getLogger('mandos')

88

89

logger = logging.Logger('mandos')

151

152

self.group = None # our entry group

152

153

self.server = None

153

154

self.bus = bus

155

self.entry_group_state_changed_match = None

154

156

def rename(self):

155

157

"""Derived from the Avahi example code"""

156

158

if self.rename_count >= self.max_renames:

158

160

" after %i retries, exiting.",

159

161

self.rename_count)

160

162

raise AvahiServiceError("Too many renames")

161

self.name = unicode(self.server.GetAlternativeServiceName(self.name))

163

self.name = unicode(self.server

164

.GetAlternativeServiceName(self.name))

162

165

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

163

166

self.name)

164

167

syslogger.setFormatter(logging.Formatter

168

171

self.remove()

169

172

try:

170

173

self.add()

171

except dbus.exceptions.DBusException, error:

174

except dbus.exceptions.DBusException as error:

172

175

logger.critical("DBusException: %s", error)

173

176

self.cleanup()

174

177

os._exit(1)

175

178

self.rename_count += 1

176

179

def remove(self):

177

180

"""Derived from the Avahi example code"""

181

if self.entry_group_state_changed_match is not None:

182

self.entry_group_state_changed_match.remove()

183

self.entry_group_state_changed_match = None

178

184

if self.group is not None:

179

185

self.group.Reset()

180

186

def add(self):

181

187

"""Derived from the Avahi example code"""

188

self.remove()

182

189

if self.group is None:

183

190

self.group = dbus.Interface(

184

191

self.bus.get_object(avahi.DBUS_NAME,

185

192

self.server.EntryGroupNew()),

186

193

avahi.DBUS_INTERFACE_ENTRY_GROUP)

187

self.group.connect_to_signal('StateChanged',

188

self

189

.entry_group_state_changed)

194

self.entry_group_state_changed_match = (

195

self.group.connect_to_signal(

196

'StateChanged', self .entry_group_state_changed))

190

197

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

191

198

self.name, self.type)

192

199

self.group.AddService(

215

222

def cleanup(self):

216

223

"""Derived from the Avahi example code"""

217

224

if self.group is not None:

218

self.group.Free()

225

try:

226

self.group.Free()

227

except (dbus.exceptions.UnknownMethodException,

228

dbus.exceptions.DBusException) as e:

229

pass

219

230

self.group = None

220

def server_state_changed(self, state):

231

self.remove()

232

def server_state_changed(self, state, error=None):

221

233

"""Derived from the Avahi example code"""

222

234

logger.debug("Avahi server state change: %i", state)

223

if state == avahi.SERVER_COLLISION:

224

logger.error("Zeroconf server name collision")

225

self.remove()

235

bad_states = { avahi.SERVER_INVALID:

236

"Zeroconf server invalid",

237

avahi.SERVER_REGISTERING: None,

238

avahi.SERVER_COLLISION:

239

"Zeroconf server name collision",

240

avahi.SERVER_FAILURE:

241

"Zeroconf server failure" }

242

if state in bad_states:

243

if bad_states[state] is not None:

244

if error is None:

245

logger.error(bad_states[state])

246

else:

247

logger.error(bad_states[state] + ": %r", error)

248

self.cleanup()

226

249

elif state == avahi.SERVER_RUNNING:

227

250

self.add()

251

else:

252

if error is None:

253

logger.debug("Unknown state: %r", state)

254

else:

255

logger.debug("Unknown state: %r: %r", state, error)

228

256

def activate(self):

229

257

"""Derived from the Avahi example code"""

230

258

if self.server is None:

231

259

self.server = dbus.Interface(

232

260

self.bus.get_object(avahi.DBUS_NAME,

233

avahi.DBUS_PATH_SERVER),

261

avahi.DBUS_PATH_SERVER,

262

follow_name_owner_changes=True),

234

263

avahi.DBUS_INTERFACE_SERVER)

235

264

self.server.connect_to_signal("StateChanged",

236

265

self.server_state_changed)

237

266

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

238

267

239

268

269

def _timedelta_to_milliseconds(td):

270

"Convert a datetime.timedelta() to milliseconds"

271

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

272

+ (td.seconds * 1000)

273

+ (td.microseconds // 1000))

274

240

275

class Client(object):

241

276

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

242

277

270

305

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

271

306

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

272

307

until this client is disabled

308

extended_timeout: extra long timeout when password has been sent

273

309

runtime_expansions: Allowed attributes for runtime expansion.

310

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

311

disabled, or None

274

312

"""

275

313

276

314

runtime_expansions = ("approval_delay", "approval_duration",

278

316

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

279

317

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

280

318

281

@staticmethod

282

def _timedelta_to_milliseconds(td):

283

"Convert a datetime.timedelta() to milliseconds"

284

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

285

+ (td.seconds * 1000)

286

+ (td.microseconds // 1000))

287

288

319

def timeout_milliseconds(self):

289

320

"Return the 'timeout' attribute in milliseconds"

290

return self._timedelta_to_milliseconds(self.timeout)

321

return _timedelta_to_milliseconds(self.timeout)

322

323

def extended_timeout_milliseconds(self):

324

"Return the 'extended_timeout' attribute in milliseconds"

325

return _timedelta_to_milliseconds(self.extended_timeout)

291

326

292

327

def interval_milliseconds(self):

293

328

"Return the 'interval' attribute in milliseconds"

294

return self._timedelta_to_milliseconds(self.interval)

295

329

return _timedelta_to_milliseconds(self.interval)

330

296

331

def approval_delay_milliseconds(self):

297

return self._timedelta_to_milliseconds(self.approval_delay)

332

return _timedelta_to_milliseconds(self.approval_delay)

298

333

299

334

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

300

335

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

327

362

self.last_enabled = None

328

363

self.last_checked_ok = None

329

364

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

365

self.extended_timeout = string_to_delta(config

366

["extended_timeout"])

330

367

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

331

368

self.disable_hook = disable_hook

332

369

self.checker = None

333

370

self.checker_initiator_tag = None

334

371

self.disable_initiator_tag = None

372

self.expires = None

335

373

self.checker_callback_tag = None

336

374

self.checker_command = config["checker"]

337

375

self.current_checker_command = None

344

382

config["approval_delay"])

345

383

self.approval_duration = string_to_delta(

346

384

config["approval_duration"])

347

self.changedstate = multiprocessing_manager.Condition(multiprocessing_manager.Lock())

385

self.changedstate = (multiprocessing_manager

386

.Condition(multiprocessing_manager

387

.Lock()))

348

388

349

389

def send_changedstate(self):

350

390

self.changedstate.acquire()

351

391

self.changedstate.notify_all()

352

392

self.changedstate.release()

353

393

354

394

def enable(self):

355

395

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

356

396

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

357

397

# Already enabled

358

398

return

359

399

self.send_changedstate()

360

self.last_enabled = datetime.datetime.utcnow()

361

400

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

362

401

# and every interval from then on.

363

402

self.checker_initiator_tag = (gobject.timeout_add

364

403

(self.interval_milliseconds(),

365

404

self.start_checker))

366

405

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

406

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

367

407

self.disable_initiator_tag = (gobject.timeout_add

368

408

(self.timeout_milliseconds(),

369

409

self.disable))

370

410

self.enabled = True

411

self.last_enabled = datetime.datetime.utcnow()

371

412

# Also start a new checker *right now*.

372

413

self.start_checker()

373

414

382

423

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

383

424

gobject.source_remove(self.disable_initiator_tag)

384

425

self.disable_initiator_tag = None

426

self.expires = None

385

427

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

386

428

gobject.source_remove(self.checker_initiator_tag)

387

429

self.checker_initiator_tag = None

413

455

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

414

456

vars(self))

415

457

416

def checked_ok(self):

458

def checked_ok(self, timeout=None):

417

459

"""Bump up the timeout for this client.

418

460

419

461

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

420

462

alive and well.

421

463

"""

464

if timeout is None:

465

timeout = self.timeout

422

466

self.last_checked_ok = datetime.datetime.utcnow()

423

gobject.source_remove(self.disable_initiator_tag)

424

self.disable_initiator_tag = (gobject.timeout_add

425

(self.timeout_milliseconds(),

426

self.disable))

467

if self.disable_initiator_tag is not None:

468

gobject.source_remove(self.disable_initiator_tag)

469

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

470

self.disable_initiator_tag = (gobject.timeout_add

471

(_timedelta_to_milliseconds

472

(timeout), self.disable))

473

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

427

474

428

475

def need_approval(self):

429

476

self.last_approval_request = datetime.datetime.utcnow()

445

492

# If a checker exists, make sure it is not a zombie

446

493

try:

447

494

pid, status = os.waitpid(self.checker.pid, os.WNOHANG)

448

except (AttributeError, OSError), error:

495

except (AttributeError, OSError) as error:

449

496

if (isinstance(error, OSError)

450

497

and error.errno != errno.ECHILD):

451

498

raise error

469

516

'replace')))

470

517

for attr in

471

518

self.runtime_expansions)

472

519

473

520

try:

474

521

command = self.checker_command % escaped_attrs

475

except TypeError, error:

522

except TypeError as error:

476

523

logger.error('Could not format string "%s":'

477

524

' %s', self.checker_command, error)

478

525

return True # Try again later

497

544

if pid:

498

545

gobject.source_remove(self.checker_callback_tag)

499

546

self.checker_callback(pid, status, command)

500

except OSError, error:

547

except OSError as error:

501

548

logger.error("Failed to start subprocess: %s",

502

549

error)

503

550

# Re-run this periodically if run by gobject.timeout_add

516

563

#time.sleep(0.5)

517

564

#if self.checker.poll() is None:

518

565

# os.kill(self.checker.pid, signal.SIGKILL)

519

except OSError, error:

566

except OSError as error:

520

567

if error.errno != errno.ESRCH: # No such process

521

568

raise

522

569

self.checker = None

523

570

571

524

572

def dbus_service_property(dbus_interface, signature="v",

525

573

access="readwrite", byte_arrays=False):

526

574

"""Decorators for marking methods of a DBusObjectWithProperties to

572

620

573

621

class DBusObjectWithProperties(dbus.service.Object):

574

622

"""A D-Bus object with properties.

575

623

576

624

Classes inheriting from this can use the dbus_service_property

577

625

decorator to expose methods as D-Bus properties. It exposes the

578

626

standard Get(), Set(), and GetAll() methods on the D-Bus.

585

633

def _get_all_dbus_properties(self):

586

634

"""Returns a generator of (name, attribute) pairs

587

635

"""

588

return ((prop._dbus_name, prop)

636

return ((prop.__get__(self)._dbus_name, prop.__get__(self))

637

for cls in self.__class__.__mro__

589

638

for name, prop in

590

inspect.getmembers(self, self._is_dbus_property))

639

inspect.getmembers(cls, self._is_dbus_property))

591

640

592

641

def _get_dbus_property(self, interface_name, property_name):

593

642

"""Returns a bound method if one exists which is a D-Bus

594

643

property with the specified name and interface.

595

644

"""

596

for name in (property_name,

597

property_name + "_dbus_property"):

598

prop = getattr(self, name, None)

599

if (prop is None

600

or not self._is_dbus_property(prop)

601

or prop._dbus_name != property_name

602

or (interface_name and prop._dbus_interface

603

and interface_name != prop._dbus_interface)):

604

continue

605

return prop

645

for cls in self.__class__.__mro__:

646

for name, value in (inspect.getmembers

647

(cls, self._is_dbus_property)):

648

if (value._dbus_name == property_name

649

and value._dbus_interface == interface_name):

650

return value.__get__(self)

651

606

652

# No such property

607

653

raise DBusPropertyNotFound(self.dbus_object_path + ":"

608

654

+ interface_name + "."

642

688

def GetAll(self, interface_name):

643

689

"""Standard D-Bus property GetAll() method, see D-Bus

644

690

standard.

645

691

646

692

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

647

693

"""

648

694

all = {}

704

750

xmlstring = document.toxml("utf-8")

705

751

document.unlink()

706

752

except (AttributeError, xml.dom.DOMException,

707

xml.parsers.expat.ExpatError), error:

753

xml.parsers.expat.ExpatError) as error:

708

754

logger.error("Failed to override Introspection method",

709

755

error)

710

756

return xmlstring

711

757

712

758

759

def datetime_to_dbus (dt, variant_level=0):

760

"""Convert a UTC datetime.datetime() to a D-Bus type."""

761

if dt is None:

762

return dbus.String("", variant_level = variant_level)

763

return dbus.String(dt.isoformat(),

764

variant_level=variant_level)

765

766

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

767

.__metaclass__):

768

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

769

will add additional D-Bus attributes matching a certain pattern.

770

"""

771

def __new__(mcs, name, bases, attr):

772

# Go through all the base classes which could have D-Bus

773

# methods, signals, or properties in them

774

for base in (b for b in bases

775

if issubclass(b, dbus.service.Object)):

776

# Go though all attributes of the base class

777

for attrname, attribute in inspect.getmembers(base):

778

# Ignore non-D-Bus attributes, and D-Bus attributes

779

# with the wrong interface name

780

if (not hasattr(attribute, "_dbus_interface")

781

or not attribute._dbus_interface

782

.startswith("se.recompile.Mandos")):

783

continue

784

# Create an alternate D-Bus interface name based on

785

# the current name

786

alt_interface = (attribute._dbus_interface

787

.replace("se.recompile.Mandos",

788

"se.bsnet.fukt.Mandos"))

789

# Is this a D-Bus signal?

790

if getattr(attribute, "_dbus_is_signal", False):

791

# Extract the original non-method function by

792

# black magic

793

nonmethod_func = (dict(

794

zip(attribute.func_code.co_freevars,

795

attribute.__closure__))["func"]

796

.cell_contents)

797

# Create a new, but exactly alike, function

798

# object, and decorate it to be a new D-Bus signal

799

# with the alternate D-Bus interface name

800

new_function = (dbus.service.signal

801

(alt_interface,

802

attribute._dbus_signature)

803

(types.FunctionType(

804

nonmethod_func.func_code,

805

nonmethod_func.func_globals,

806

nonmethod_func.func_name,

807

nonmethod_func.func_defaults,

808

nonmethod_func.func_closure)))

809

# Define a creator of a function to call both the

810

# old and new functions, so both the old and new

811

# signals gets sent when the function is called

812

def fixscope(func1, func2):

813

"""This function is a scope container to pass

814

func1 and func2 to the "call_both" function

815

outside of its arguments"""

816

def call_both(*args, **kwargs):

817

"""This function will emit two D-Bus

818

signals by calling func1 and func2"""

819

func1(*args, **kwargs)

820

func2(*args, **kwargs)

821

return call_both

822

# Create the "call_both" function and add it to

823

# the class

824

attr[attrname] = fixscope(attribute,

825

new_function)

826

# Is this a D-Bus method?

827

elif getattr(attribute, "_dbus_is_method", False):

828

# Create a new, but exactly alike, function

829

# object. Decorate it to be a new D-Bus method

830

# with the alternate D-Bus interface name. Add it

831

# to the class.

832

attr[attrname] = (dbus.service.method

833

(alt_interface,

834

attribute._dbus_in_signature,

835

attribute._dbus_out_signature)

836

(types.FunctionType

837

(attribute.func_code,

838

attribute.func_globals,

839

attribute.func_name,

840

attribute.func_defaults,

841

attribute.func_closure)))

842

# Is this a D-Bus property?

843

elif getattr(attribute, "_dbus_is_property", False):

844

# Create a new, but exactly alike, function

845

# object, and decorate it to be a new D-Bus

846

# property with the alternate D-Bus interface

847

# name. Add it to the class.

848

attr[attrname] = (dbus_service_property

849

(alt_interface,

850

attribute._dbus_signature,

851

attribute._dbus_access,

852

attribute

853

._dbus_get_args_options

854

["byte_arrays"])

855

(types.FunctionType

856

(attribute.func_code,

857

attribute.func_globals,

858

attribute.func_name,

859

attribute.func_defaults,

860

attribute.func_closure)))

861

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

862

713

863

class ClientDBus(Client, DBusObjectWithProperties):

714

864

"""A Client class using D-Bus

715

865

737

887

DBusObjectWithProperties.__init__(self, self.bus,

738

888

self.dbus_object_path)

739

889

740

def _get_approvals_pending(self):

741

return self._approvals_pending

742

def _set_approvals_pending(self, value):

743

old_value = self._approvals_pending

744

self._approvals_pending = value

745

bval = bool(value)

746

if (hasattr(self, "dbus_object_path")

747

and bval is not bool(old_value)):

748

dbus_bool = dbus.Boolean(bval, variant_level=1)

749

self.PropertyChanged(dbus.String("ApprovalPending"),

750

dbus_bool)

890

def notifychangeproperty(transform_func,

891

dbus_name, type_func=lambda x: x,

892

variant_level=1):

893

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

894

its changes to DBus.

751

895

752

approvals_pending = property(_get_approvals_pending,

753

_set_approvals_pending)

754

del _get_approvals_pending, _set_approvals_pending

755

756

@staticmethod

757

def _datetime_to_dbus(dt, variant_level=0):

758

"""Convert a UTC datetime.datetime() to a D-Bus type."""

759

return dbus.String(dt.isoformat(),

760

variant_level=variant_level)

761

762

def enable(self):

763

oldstate = getattr(self, "enabled", False)

764

r = Client.enable(self)

765

if oldstate != self.enabled:

766

# Emit D-Bus signals

767

self.PropertyChanged(dbus.String("Enabled"),

768

dbus.Boolean(True, variant_level=1))

769

self.PropertyChanged(

770

dbus.String("LastEnabled"),

771

self._datetime_to_dbus(self.last_enabled,

772

variant_level=1))

773

return r

774

775

def disable(self, quiet = False):

776

oldstate = getattr(self, "enabled", False)

777

r = Client.disable(self, quiet=quiet)

778

if not quiet and oldstate != self.enabled:

779

# Emit D-Bus signal

780

self.PropertyChanged(dbus.String("Enabled"),

781

dbus.Boolean(False, variant_level=1))

782

return r

896

transform_fun: Function that takes a value and a variant_level

897

and transforms it to a D-Bus type.

898

dbus_name: D-Bus name of the variable

899

type_func: Function that transform the value before sending it

900

to the D-Bus. Default: no transform

901

variant_level: D-Bus variant level. Default: 1

902

"""

903

attrname = "_{0}".format(dbus_name)

904

def setter(self, value):

905

if hasattr(self, "dbus_object_path"):

906

if (not hasattr(self, attrname) or

907

type_func(getattr(self, attrname, None))

908

!= type_func(value)):

909

dbus_value = transform_func(type_func(value),

910

variant_level

911

=variant_level)

912

self.PropertyChanged(dbus.String(dbus_name),

913

dbus_value)

914

setattr(self, attrname, value)

915

916

return property(lambda self: getattr(self, attrname), setter)

917

918

919

expires = notifychangeproperty(datetime_to_dbus, "Expires")

920

approvals_pending = notifychangeproperty(dbus.Boolean,

921

"ApprovalPending",

922

type_func = bool)

923

enabled = notifychangeproperty(dbus.Boolean, "Enabled")

924

last_enabled = notifychangeproperty(datetime_to_dbus,

925

"LastEnabled")

926

checker = notifychangeproperty(dbus.Boolean, "CheckerRunning",

927

type_func = lambda checker:

928

checker is not None)

929

last_checked_ok = notifychangeproperty(datetime_to_dbus,

930

"LastCheckedOK")

931

last_approval_request = notifychangeproperty(

932

datetime_to_dbus, "LastApprovalRequest")

933

approved_by_default = notifychangeproperty(dbus.Boolean,

934

"ApprovedByDefault")

935

approval_delay = notifychangeproperty(dbus.UInt16,

936

"ApprovalDelay",

937

type_func =

938

_timedelta_to_milliseconds)

939

approval_duration = notifychangeproperty(

940

dbus.UInt16, "ApprovalDuration",

941

type_func = _timedelta_to_milliseconds)

942

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

943

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

944

type_func =

945

_timedelta_to_milliseconds)

946

extended_timeout = notifychangeproperty(

947

dbus.UInt16, "ExtendedTimeout",

948

type_func = _timedelta_to_milliseconds)

949

interval = notifychangeproperty(dbus.UInt16,

950

"Interval",

951

type_func =

952

_timedelta_to_milliseconds)

953

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

954

955

del notifychangeproperty

783

956

784

957

def __del__(self, *args, **kwargs):

785

958

try:

794

967

*args, **kwargs):

795

968

self.checker_callback_tag = None

796

969

self.checker = None

797

# Emit D-Bus signal

798

self.PropertyChanged(dbus.String("CheckerRunning"),

799

dbus.Boolean(False, variant_level=1))

800

970

if os.WIFEXITED(condition):

801

971

exitstatus = os.WEXITSTATUS(condition)

802

972

# Emit D-Bus signal

812

982

return Client.checker_callback(self, pid, condition, command,

813

983

*args, **kwargs)

814

984

815

def checked_ok(self, *args, **kwargs):

816

r = Client.checked_ok(self, *args, **kwargs)

817

# Emit D-Bus signal

818

self.PropertyChanged(

819

dbus.String("LastCheckedOK"),

820

(self._datetime_to_dbus(self.last_checked_ok,

821

variant_level=1)))

822

return r

823

824

def need_approval(self, *args, **kwargs):

825

r = Client.need_approval(self, *args, **kwargs)

826

# Emit D-Bus signal

827

self.PropertyChanged(

828

dbus.String("LastApprovalRequest"),

829

(self._datetime_to_dbus(self.last_approval_request,

830

variant_level=1)))

831

return r

832

833

985

def start_checker(self, *args, **kwargs):

834

986

old_checker = self.checker

835

987

if self.checker is not None:

842

994

and old_checker_pid != self.checker.pid):

843

995

# Emit D-Bus signal

844

996

self.CheckerStarted(self.current_checker_command)

845

self.PropertyChanged(

846

dbus.String("CheckerRunning"),

847

dbus.Boolean(True, variant_level=1))

848

997

return r

849

998

850

def stop_checker(self, *args, **kwargs):

851

old_checker = getattr(self, "checker", None)

852

r = Client.stop_checker(self, *args, **kwargs)

853

if (old_checker is not None

854

and getattr(self, "checker", None) is None):

855

self.PropertyChanged(dbus.String("CheckerRunning"),

856

dbus.Boolean(False, variant_level=1))

857

return r

858

859

999

def _reset_approved(self):

860

1000

self._approved = None

861

1001

return False

863

1003

def approve(self, value=True):

864

1004

self.send_changedstate()

865

1005

self._approved = value

866

gobject.timeout_add(self._timedelta_to_milliseconds

1006

gobject.timeout_add(_timedelta_to_milliseconds

867

1007

(self.approval_duration),

868

1008

self._reset_approved)

869

1009

870

1010

871

1011

## D-Bus methods, signals & properties

872

_interface = "se.bsnet.fukt.Mandos.Client"

1012

_interface = "se.recompile.Mandos.Client"

873

1013

874

1014

## Signals

875

1015

922

1062

# CheckedOK - method

923

1063

@dbus.service.method(_interface)

924

1064

def CheckedOK(self):

925

return self.checked_ok()

1065

self.checked_ok()

926

1066

927

1067

# Enable - method

928

1068

@dbus.service.method(_interface)

961

1101

if value is None: # get

962

1102

return dbus.Boolean(self.approved_by_default)

963

1103

self.approved_by_default = bool(value)

964

# Emit D-Bus signal

965

self.PropertyChanged(dbus.String("ApprovedByDefault"),

966

dbus.Boolean(value, variant_level=1))

967

1104

968

1105

# ApprovalDelay - property

969

1106

@dbus_service_property(_interface, signature="t",

972

1109

if value is None: # get

973

1110

return dbus.UInt64(self.approval_delay_milliseconds())

974

1111

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

975

# Emit D-Bus signal

976

self.PropertyChanged(dbus.String("ApprovalDelay"),

977

dbus.UInt64(value, variant_level=1))

978

1112

979

1113

# ApprovalDuration - property

980

1114

@dbus_service_property(_interface, signature="t",

981

1115

access="readwrite")

982

1116

def ApprovalDuration_dbus_property(self, value=None):

983

1117

if value is None: # get

984

return dbus.UInt64(self._timedelta_to_milliseconds(

1118

return dbus.UInt64(_timedelta_to_milliseconds(

985

1119

self.approval_duration))

986

1120

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

987

# Emit D-Bus signal

988

self.PropertyChanged(dbus.String("ApprovalDuration"),

989

dbus.UInt64(value, variant_level=1))

990

1121

991

1122

# Name - property

992

1123

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

1005

1136

if value is None: # get

1006

1137

return dbus.String(self.host)

1007

1138

self.host = value

1008

# Emit D-Bus signal

1009

self.PropertyChanged(dbus.String("Host"),

1010

dbus.String(value, variant_level=1))

1011

1139

1012

1140

# Created - property

1013

1141

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

1014

1142

def Created_dbus_property(self):

1015

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

1143

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

1016

1144

1017

1145

# LastEnabled - property

1018

1146

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

1019

1147

def LastEnabled_dbus_property(self):

1020

if self.last_enabled is None:

1021

return dbus.String("")

1022

return dbus.String(self._datetime_to_dbus(self.last_enabled))

1148

return datetime_to_dbus(self.last_enabled)

1023

1149

1024

1150

# Enabled - property

1025

1151

@dbus_service_property(_interface, signature="b",

1039

1165

if value is not None:

1040

1166

self.checked_ok()

1041

1167

return

1042

if self.last_checked_ok is None:

1043

return dbus.String("")

1044

return dbus.String(self._datetime_to_dbus(self

1045

.last_checked_ok))

1168

return datetime_to_dbus(self.last_checked_ok)

1169

1170

# Expires - property

1171

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

1172

def Expires_dbus_property(self):

1173

return datetime_to_dbus(self.expires)

1046

1174

1047

1175

# LastApprovalRequest - property

1048

1176

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

1049

1177

def LastApprovalRequest_dbus_property(self):

1050

if self.last_approval_request is None:

1051

return dbus.String("")

1052

return dbus.String(self.

1053

_datetime_to_dbus(self

1054

.last_approval_request))

1178

return datetime_to_dbus(self.last_approval_request)

1055

1179

1056

1180

# Timeout - property

1057

1181

@dbus_service_property(_interface, signature="t",

1060

1184

if value is None: # get

1061

1185

return dbus.UInt64(self.timeout_milliseconds())

1062

1186

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

1063

# Emit D-Bus signal

1064

self.PropertyChanged(dbus.String("Timeout"),

1065

dbus.UInt64(value, variant_level=1))

1066

1187

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

1067

1188

return

1068

1189

# Reschedule timeout

1069

1190

gobject.source_remove(self.disable_initiator_tag)

1070

1191

self.disable_initiator_tag = None

1071

time_to_die = (self.

1072

_timedelta_to_milliseconds((self

1073

.last_checked_ok

1074

+ self.timeout)

1075

- datetime.datetime

1076

.utcnow()))

1192

self.expires = None

1193

time_to_die = _timedelta_to_milliseconds((self

1194

.last_checked_ok

1195

+ self.timeout)

1196

- datetime.datetime

1197

.utcnow())

1077

1198

if time_to_die <= 0:

1078

1199

# The timeout has passed

1079

1200

self.disable()

1080

1201

else:

1202

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

1203

+ datetime.timedelta(milliseconds =

1204

time_to_die))

1081

1205

self.disable_initiator_tag = (gobject.timeout_add

1082

1206

(time_to_die, self.disable))

1083

1207

1208

# ExtendedTimeout - property

1209

@dbus_service_property(_interface, signature="t",

1210

access="readwrite")

1211

def ExtendedTimeout_dbus_property(self, value=None):

1212

if value is None: # get

1213

return dbus.UInt64(self.extended_timeout_milliseconds())

1214

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

1215

1084

1216

# Interval - property

1085

1217

@dbus_service_property(_interface, signature="t",

1086

1218

access="readwrite")

1088

1220

if value is None: # get

1089

1221

return dbus.UInt64(self.interval_milliseconds())

1090

1222

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

1091

# Emit D-Bus signal

1092

self.PropertyChanged(dbus.String("Interval"),

1093

dbus.UInt64(value, variant_level=1))

1094

1223

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

1095

1224

return

1096

1225

# Reschedule checker run

1098

1227

self.checker_initiator_tag = (gobject.timeout_add

1099

1228

(value, self.start_checker))

1100

1229

self.start_checker() # Start one now, too

1101

1230

1102

1231

# Checker - property

1103

1232

@dbus_service_property(_interface, signature="s",

1104

1233

access="readwrite")

1106

1235

if value is None: # get

1107

1236

return dbus.String(self.checker_command)

1108

1237

self.checker_command = value

1109

# Emit D-Bus signal

1110

self.PropertyChanged(dbus.String("Checker"),

1111

dbus.String(self.checker_command,

1112

variant_level=1))

1113

1238

1114

1239

# CheckerRunning - property

1115

1240

@dbus_service_property(_interface, signature="b",

1142

1267

self._pipe.send(('init', fpr, address))

1143

1268

if not self._pipe.recv():

1144

1269

raise KeyError()

1145

1270

1146

1271

def __getattribute__(self, name):

1147

1272

if(name == '_pipe'):

1148

1273

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

1155

1280

self._pipe.send(('funcall', name, args, kwargs))

1156

1281

return self._pipe.recv()[1]

1157

1282

return func

1158

1283

1159

1284

def __setattr__(self, name, value):

1160

1285

if(name == '_pipe'):

1161

1286

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

1162

1287

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

1163

1288

1289

class ClientDBusTransitional(ClientDBus):

1290

__metaclass__ = AlternateDBusNamesMetaclass

1164

1291

1165

1292

class ClientHandler(socketserver.BaseRequestHandler, object):

1166

1293

"""A class to handle client connections.

1174

1301

unicode(self.client_address))

1175

1302

logger.debug("Pipe FD: %d",

1176

1303

self.server.child_pipe.fileno())

1177

1304

1178

1305

session = (gnutls.connection

1179

1306

.ClientSession(self.request,

1180

1307

gnutls.connection

1181

1308

.X509Credentials()))

1182

1309

1183

1310

# Note: gnutls.connection.X509Credentials is really a

1184

1311

# generic GnuTLS certificate credentials object so long as

1185

1312

# no X.509 keys are added to it. Therefore, we can use it

1186

1313

# here despite using OpenPGP certificates.

1187

1314

1188

1315

#priority = ':'.join(("NONE", "+VERS-TLS1.1",

1189

1316

# "+AES-256-CBC", "+SHA1",

1190

1317

# "+COMP-NULL", "+CTYPE-OPENPGP",

1196

1323

(gnutls.library.functions

1197

1324

.gnutls_priority_set_direct(session._c_object,

1198

1325

priority, None))

1199

1326

1200

1327

# Start communication using the Mandos protocol

1201

1328

# Get protocol number

1202

1329

line = self.request.makefile().readline()

1204

1331

try:

1205

1332

if int(line.strip().split()[0]) > 1:

1206

1333

raise RuntimeError

1207

except (ValueError, IndexError, RuntimeError), error:

1334

except (ValueError, IndexError, RuntimeError) as error:

1208

1335

logger.error("Unknown protocol version: %s", error)

1209

1336

return

1210

1337

1211

1338

# Start GnuTLS connection

1212

1339

try:

1213

1340

session.handshake()

1214

except gnutls.errors.GNUTLSError, error:

1341

except gnutls.errors.GNUTLSError as error:

1215

1342

logger.warning("Handshake failed: %s", error)

1216

1343

# Do not run session.bye() here: the session is not

1217

1344

# established. Just abandon the request.

1218

1345

return

1219

1346

logger.debug("Handshake succeeded")

1220

1347

1221

1348

approval_required = False

1222

1349

try:

1223

1350

try:

1224

1351

fpr = self.fingerprint(self.peer_certificate

1225

1352

(session))

1226

except (TypeError, gnutls.errors.GNUTLSError), error:

1353

except (TypeError,

1354

gnutls.errors.GNUTLSError) as error:

1227

1355

logger.warning("Bad certificate: %s", error)

1228

1356

return

1229

1357

logger.debug("Fingerprint: %s", fpr)

1230

1358

1231

1359

try:

1232

1360

client = ProxyClient(child_pipe, fpr,

1233

1361

self.client_address)

1241

1369

1242

1370

while True:

1243

1371

if not client.enabled:

1244

logger.warning("Client %s is disabled",

1372

logger.info("Client %s is disabled",

1245

1373

client.name)

1246

1374

if self.server.use_dbus:

1247

1375

# Emit D-Bus signal

1248

client.Rejected("Disabled")

1376

client.Rejected("Disabled")

1249

1377

return

1250

1378

1251

1379

if client._approved or not client.approval_delay:

1268

1396

return

1269

1397

1270

1398

#wait until timeout or approved

1271

#x = float(client._timedelta_to_milliseconds(delay))

1272

1399

time = datetime.datetime.now()

1273

1400

client.changedstate.acquire()

1274

client.changedstate.wait(float(client._timedelta_to_milliseconds(delay) / 1000))

1401

(client.changedstate.wait

1402

(float(client._timedelta_to_milliseconds(delay)

1403

/ 1000)))

1275

1404

client.changedstate.release()

1276

1405

time2 = datetime.datetime.now()

1277

1406

if (time2 - time) >= delay:

1292

1421

while sent_size < len(client.secret):

1293

1422

try:

1294

1423

sent = session.send(client.secret[sent_size:])

1295

except (gnutls.errors.GNUTLSError), error:

1424

except gnutls.errors.GNUTLSError as error:

1296

1425

logger.warning("gnutls send failed")

1297

1426

return

1298

1427

logger.debug("Sent: %d, remaining: %d",

1299

1428

sent, len(client.secret)

1300

1429

- (sent_size + sent))

1301

1430

sent_size += sent

1302

1431

1303

1432

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

1304

# bump the timeout as if seen

1305

client.checked_ok()

1433

# bump the timeout using extended_timeout

1434

client.checked_ok(client.extended_timeout)

1306

1435

if self.server.use_dbus:

1307

1436

# Emit D-Bus signal

1308

1437

client.GotSecret()

1312

1441

client.approvals_pending -= 1

1313

1442

try:

1314

1443

session.bye()

1315

except (gnutls.errors.GNUTLSError), error:

1444

except gnutls.errors.GNUTLSError as error:

1316

1445

logger.warning("GnuTLS bye failed")

1317

1446

1318

1447

@staticmethod

1387

1516

except:

1388

1517

self.handle_error(request, address)

1389

1518

self.close_request(request)

1390

1519

1391

1520

def process_request(self, request, address):

1392

1521

"""Start a new process to process the request."""

1393

multiprocessing.Process(target = self.sub_process_main,

1394

args = (request, address)).start()

1522

proc = multiprocessing.Process(target = self.sub_process_main,

1523

args = (request,

1524

address))

1525

proc.start()

1526

return proc

1527

1395

1528

1396

1529

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1397

1530

""" adds a pipe to the MixIn """

1401

1534

This function creates a new pipe in self.pipe

1402

1535

"""

1403

1536

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1404

1405

super(MultiprocessingMixInWithPipe,

1406

self).process_request(request, client_address)

1537

1538

proc = MultiprocessingMixIn.process_request(self, request,

1539

client_address)

1407

1540

self.child_pipe.close()

1408

self.add_pipe(parent_pipe)

1409

1410

def add_pipe(self, parent_pipe):

1541

self.add_pipe(parent_pipe, proc)

1542

1543

def add_pipe(self, parent_pipe, proc):

1411

1544

"""Dummy function; override as necessary"""

1412

1545

raise NotImplementedError

1413

1546

1547

1414

1548

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1415

1549

socketserver.TCPServer, object):

1416

1550

"""IPv6-capable TCP server. Accepts 'None' as address and/or port

1442

1576

SO_BINDTODEVICE,

1443

1577

str(self.interface

1444

1578

+ '\0'))

1445

except socket.error, error:

1579

except socket.error as error:

1446

1580

if error[0] == errno.EPERM:

1447

1581

logger.error("No permission to"

1448

1582

" bind to interface %s",

1500

1634

def server_activate(self):

1501

1635

if self.enabled:

1502

1636

return socketserver.TCPServer.server_activate(self)

1637

1503

1638

def enable(self):

1504

1639

self.enabled = True

1505

def add_pipe(self, parent_pipe):

1640

1641

def add_pipe(self, parent_pipe, proc):

1506

1642

# Call "handle_ipc" for both data and EOF events

1507

1643

gobject.io_add_watch(parent_pipe.fileno(),

1508

1644

gobject.IO_IN | gobject.IO_HUP,

1509

1645

functools.partial(self.handle_ipc,

1510

parent_pipe = parent_pipe))

1511

1646

parent_pipe =

1647

parent_pipe,

1648

proc = proc))

1649

1512

1650

def handle_ipc(self, source, condition, parent_pipe=None,

1513

client_object=None):

1651

proc = None, client_object=None):

1514

1652

condition_names = {

1515

1653

gobject.IO_IN: "IN", # There is data to read.

1516

1654

gobject.IO_OUT: "OUT", # Data can be written (without

1525

1663

for cond, name in

1526

1664

condition_names.iteritems()

1527

1665

if cond & condition)

1528

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

1666

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

1529

1667

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

1668

# Wait for other process to exit

1669

proc.join()

1530

1670

return False

1531

1671

1532

1672

# Read a request from the child

1542

1682

client = c

1543

1683

break

1544

1684

else:

1545

logger.warning("Client not found for fingerprint: %s, ad"

1546

"dress: %s", fpr, address)

1685

logger.info("Client not found for fingerprint: %s, ad"

1686

"dress: %s", fpr, address)

1547

1687

if self.use_dbus:

1548

1688

# Emit D-Bus signal

1549

mandos_dbus_service.ClientNotFound(fpr, address[0])

1689

mandos_dbus_service.ClientNotFound(fpr,

1690

address[0])

1550

1691

parent_pipe.send(False)

1551

1692

return False

1552

1693

1553

1694

gobject.io_add_watch(parent_pipe.fileno(),

1554

1695

gobject.IO_IN | gobject.IO_HUP,

1555

1696

functools.partial(self.handle_ipc,

1556

parent_pipe = parent_pipe,

1557

client_object = client))

1697

parent_pipe =

1698

parent_pipe,

1699

proc = proc,

1700

client_object =

1701

client))

1558

1702

parent_pipe.send(True)

1559

# remove the old hook in favor of the new above hook on same fileno

1703

# remove the old hook in favor of the new above hook on

1704

# same fileno

1560

1705

return False

1561

1706

if command == 'funcall':

1562

1707

funcname = request[1]

1563

1708

args = request[2]

1564

1709

kwargs = request[3]

1565

1710

1566

parent_pipe.send(('data', getattr(client_object, funcname)(*args, **kwargs)))

1567

1711

parent_pipe.send(('data', getattr(client_object,

1712

funcname)(*args,

1713

**kwargs)))

1714

1568

1715

if command == 'getattr':

1569

1716

attrname = request[1]

1570

1717

if callable(client_object.__getattribute__(attrname)):

1571

1718

parent_pipe.send(('function',))

1572

1719

else:

1573

parent_pipe.send(('data', client_object.__getattribute__(attrname)))

1720

parent_pipe.send(('data', client_object

1721

.__getattribute__(attrname)))

1574

1722

1575

1723

if command == 'setattr':

1576

1724

attrname = request[1]

1577

1725

value = request[2]

1578

1726

setattr(client_object, attrname, value)

1579

1727

1580

1728

return True

1581

1729

1582

1730

1613

1761

delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

1614

1762

else:

1615

1763

raise ValueError("Unknown suffix %r" % suffix)

1616

except (ValueError, IndexError), e:

1764

except (ValueError, IndexError) as e:

1617

1765

raise ValueError(*(e.args))

1618

1766

timevalue += delta

1619

1767

return timevalue

1761

1909

debuglevel = server_settings["debuglevel"]

1762

1910

use_dbus = server_settings["use_dbus"]

1763

1911

use_ipv6 = server_settings["use_ipv6"]

1764

1912

1765

1913

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

1766

1914

syslogger.setFormatter(logging.Formatter

1767

1915

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

1769

1917

% server_settings["servicename"]))

1770

1918

1771

1919

# Parse config file with clients

1772

client_defaults = { "timeout": "1h",

1773

"interval": "5m",

1920

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

1921

"extended_timeout": "15m",

1922

"interval": "2m",

1774

1923

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

1775

1924

"host": "",

1776

1925

"approval_delay": "0s",

1816

1965

try:

1817

1966

os.setgid(gid)

1818

1967

os.setuid(uid)

1819

except OSError, error:

1968

except OSError as error:

1820

1969

if error[0] != errno.EPERM:

1821

1970

raise error

1822

1971

1827

1976

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

1828

1977

syslogger.setLevel(level)

1829

1978

console.setLevel(level)

1830

1979

1831

1980

if debug:

1832

1981

# Enable all possible GnuTLS debugging

1833

1982

1864

2013

# End of Avahi example code

1865

2014

if use_dbus:

1866

2015

try:

1867

bus_name = dbus.service.BusName("se.bsnet.fukt.Mandos",

2016

bus_name = dbus.service.BusName("se.recompile.Mandos",

1868

2017

bus, do_not_queue=True)

1869

except dbus.exceptions.NameExistsException, e:

2018

old_bus_name = (dbus.service.BusName

2019

("se.bsnet.fukt.Mandos", bus,

2020

do_not_queue=True))

2021

except dbus.exceptions.NameExistsException as e:

1870

2022

logger.error(unicode(e) + ", disabling D-Bus")

1871

2023

use_dbus = False

1872

2024

server_settings["use_dbus"] = False

1884

2036

1885

2037

client_class = Client

1886

2038

if use_dbus:

1887

client_class = functools.partial(ClientDBus, bus = bus)

2039

client_class = functools.partial(ClientDBusTransitional,

2040

bus = bus)

1888

2041

def client_config_items(config, section):

1889

2042

special_settings = {

1890

2043

"approved_by_default":

1920

2073

del pidfilename

1921

2074

1922

2075

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

1923

2076

1924

2077

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

1925

2078

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

1926

2079

1929

2082

"""A D-Bus proxy object"""

1930

2083

def __init__(self):

1931

2084

dbus.service.Object.__init__(self, bus, "/")

1932

_interface = "se.bsnet.fukt.Mandos"

2085

_interface = "se.recompile.Mandos"

1933

2086

1934

2087

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

1935

2088

def ClientAdded(self, objpath):

1977

2130

1978

2131

del _interface

1979

2132

1980

mandos_dbus_service = MandosDBusService()

2133

class MandosDBusServiceTransitional(MandosDBusService):

2134

__metaclass__ = AlternateDBusNamesMetaclass

2135

mandos_dbus_service = MandosDBusServiceTransitional()

1981

2136

1982

2137

def cleanup():

1983

2138

"Cleanup function; run on exit"

1984

2139

service.cleanup()

1985

2140

2141

multiprocessing.active_children()

1986

2142

while tcp_server.clients:

1987

2143

client = tcp_server.clients.pop()

1988

2144

if use_dbus:

1992

2148

client.disable(quiet=True)

1993

2149

if use_dbus:

1994

2150

# Emit D-Bus signal

1995

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

2151

mandos_dbus_service.ClientRemoved(client

2152

.dbus_object_path,

1996

2153

client.name)

1997

2154

1998

2155

atexit.register(cleanup)

2022

2179

# From the Avahi example code

2023

2180

try:

2024

2181

service.activate()

2025

except dbus.exceptions.DBusException, error:

2182

except dbus.exceptions.DBusException as error:

2026

2183

logger.critical("DBusException: %s", error)

2027

2184

cleanup()

2028

2185

sys.exit(1)

2035

2192

2036

2193

logger.debug("Starting main loop")

2037

2194

main_loop.run()

2038

except AvahiError, error:

2195

except AvahiError as error:

2039

2196

logger.critical("AvahiError: %s", error)

2040

2197

cleanup()

2041

2198

sys.exit(1)

2047

2204

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

2048

2205

cleanup()

2049

2206

2207

2050

2208

if __name__ == '__main__':

2051

2209

main()