/mandos/trunk : revision 407

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

55

import logging

56

import logging.handlers

57

import pwd

58

import contextlib

58

from contextlib import closing

59

import struct

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

64

62

65

63

import dbus

66

64

import dbus.service

81

79

SO_BINDTODEVICE = None

82

80

83

81

84

version = "1.2"

82

version = "1.0.14"

85

83

86

#logger = logging.getLogger(u'mandos')

87

84

logger = logging.Logger(u'mandos')

88

85

syslogger = (logging.handlers.SysLogHandler

89

86

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

157

154

u" after %i retries, exiting.",

158

155

self.rename_count)

159

156

raise AvahiServiceError(u"Too many renames")

160

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

157

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

161

158

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

162

self.name)

159

unicode(self.name))

163

160

syslogger.setFormatter(logging.Formatter

164

161

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

165

162

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

166

163

% self.name))

167

164

self.remove()

168

try:

169

self.add()

170

except dbus.exceptions.DBusException, error:

171

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

172

self.cleanup()

173

os._exit(1)

165

self.add()

174

166

self.rename_count += 1

175

167

def remove(self):

176

168

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

199

191

self.group.Commit()

200

192

def entry_group_state_changed(self, state, error):

201

193

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

202

logger.debug(u"Avahi entry group state change: %i", state)

194

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

203

195

204

196

if state == avahi.ENTRY_GROUP_ESTABLISHED:

205

197

logger.debug(u"Zeroconf service established.")

218

210

self.group = None

219

211

def server_state_changed(self, state):

220

212

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

221

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

222

213

if state == avahi.SERVER_COLLISION:

223

214

logger.error(u"Zeroconf server name collision")

224

215

self.remove()

240

231

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

241

232

242

233

Attributes:

243

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

244

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

245

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

234

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

235

D-Bus identifiers

236

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

237

uniquely identify the client

238

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

239

host: string; available for use by the checker command

240

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

241

last_enabled: datetime.datetime(); (UTC)

242

enabled: bool()

243

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

244

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

245

until this client is invalid

246

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

247

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

246

248

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

247

249

to see if the client lives.

248

250

'None' if no process is running.

249

checker_callback_tag: a gobject event source tag, or None

250

checker_command: string; External command which is run to check

251

if client lives. %() expansions are done at

251

checker_initiator_tag: a gobject event source tag, or None

252

disable_initiator_tag: - '' -

253

checker_callback_tag: - '' -

254

checker_command: string; External command which is run to check if

255

client lives. %() expansions are done at

252

256

runtime with vars(self) as dict, so that for

253

257

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

254

checker_initiator_tag: a gobject event source tag, or None

255

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

256

258

current_checker_command: string; current running checker_command

257

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

258

disable_initiator_tag: a gobject event source tag, or None

259

enabled: bool()

260

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

261

uniquely identify the client

262

host: string; available for use by the checker command

263

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

264

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

265

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

266

last_enabled: datetime.datetime(); (UTC)

267

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

268

D-Bus identifiers

269

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

270

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

271

until this client is disabled

272

runtime_expansions: Allowed attributes for runtime expansion.

273

259

"""

274

260

275

runtime_expansions = (u"approval_delay", u"approval_duration",

276

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

277

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

278

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

279

280

261

@staticmethod

281

262

def _timedelta_to_milliseconds(td):

282

263

"Convert a datetime.timedelta() to milliseconds"

291

272

def interval_milliseconds(self):

292

273

"Return the 'interval' attribute in milliseconds"

293

274

return self._timedelta_to_milliseconds(self.interval)

294

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

297

275

298

276

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

299

277

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

312

290

if u"secret" in config:

313

291

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

314

292

elif u"secfile" in config:

315

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

316

(config[u"secfile"])),

317

"rb") as secfile:

293

with closing(open(os.path.expanduser

294

(os.path.expandvars

295

(config[u"secfile"])),

296

"rb")) as secfile:

318

297

self.secret = secfile.read()

319

298

else:

320

299

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

322

301

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

323

302

self.created = datetime.datetime.utcnow()

324

303

self.enabled = False

325

self.last_approval_request = None

326

304

self.last_enabled = None

327

305

self.last_checked_ok = None

328

306

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

335

313

self.checker_command = config[u"checker"]

336

314

self.current_checker_command = None

337

315

self.last_connect = None

338

self._approved = None

339

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

340

True)

341

self.approvals_pending = 0

342

self.approval_delay = string_to_delta(

343

config[u"approval_delay"])

344

self.approval_duration = string_to_delta(

345

config[u"approval_duration"])

346

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

347

316

348

def send_changedstate(self):

349

self.changedstate.acquire()

350

self.changedstate.notify_all()

351

self.changedstate.release()

352

353

317

def enable(self):

354

318

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

355

319

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

356

320

# Already enabled

357

321

return

358

self.send_changedstate()

359

322

self.last_enabled = datetime.datetime.utcnow()

360

323

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

361

324

# and every interval from then on.

375

338

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

376

339

return False

377

340

if not quiet:

378

self.send_changedstate()

379

if not quiet:

380

341

logger.info(u"Disabling client %s", self.name)

381

342

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

382

343

gobject.source_remove(self.disable_initiator_tag)

424

385

(self.timeout_milliseconds(),

425

386

self.disable))

426

387

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

430

388

def start_checker(self):

431

389

"""Start a new checker subprocess if one is not running.

432

390

438

396

# client would inevitably timeout, since no checker would get

439

397

# a chance to run to completion. If we instead leave running

440

398

# checkers alone, the checker would have to take more time

441

# than 'timeout' for the client to be disabled, which is as it

442

# should be.

399

# than 'timeout' for the client to be declared invalid, which

400

# is as it should be.

443

401

444

402

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

445

403

try:

461

419

command = self.checker_command % self.host

462

420

except TypeError:

463

421

# Escape attributes for the shell

464

escaped_attrs = dict(

465

(attr,

466

re.escape(unicode(str(getattr(self, attr, u"")),

467

errors=

468

u'replace')))

469

for attr in

470

self.runtime_expansions)

471

422

escaped_attrs = dict((key,

423

re.escape(unicode(str(val),

424

errors=

425

u'replace')))

426

for key, val in

427

vars(self).iteritems())

472

428

try:

473

429

command = self.checker_command % escaped_attrs

474

430

except TypeError, error:

519

475

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

520

476

raise

521

477

self.checker = None

478

479

def still_valid(self):

480

"""Has the timeout not yet passed for this client?"""

481

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

482

return False

483

now = datetime.datetime.utcnow()

484

if self.last_checked_ok is None:

485

return now < (self.created + self.timeout)

486

else:

487

return now < (self.last_checked_ok + self.timeout)

488

522

489

523

490

def dbus_service_property(dbus_interface, signature=u"v",

524

491

access=u"readwrite", byte_arrays=False):

532

499

dbus.service.method, except there is only "signature", since the

533

500

type from Get() and the type sent to Set() is the same.

534

501

"""

535

# Encoding deeply encoded byte arrays is not supported yet by the

536

# "Set" method, so we fail early here:

537

if byte_arrays and signature != u"ay":

538

raise ValueError(u"Byte arrays not supported for non-'ay'"

539

u" signature %r" % signature)

540

502

def decorator(func):

541

503

func._dbus_is_property = True

542

504

func._dbus_interface = dbus_interface

628

590

if prop._dbus_access == u"read":

629

591

raise DBusPropertyAccessException(property_name)

630

592

if prop._dbus_get_args_options[u"byte_arrays"]:

631

# The byte_arrays option is not supported yet on

632

# signatures other than "ay".

633

if prop._dbus_signature != u"ay":

634

raise ValueError

635

593

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

636

594

for byte in value))

637

595

prop(value)

716

674

dbus_object_path: dbus.ObjectPath

717

675

bus: dbus.SystemBus()

718

676

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

723

677

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

724

678

725

679

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

726

self._approvals_pending = 0

727

680

self.bus = bus

728

681

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

729

682

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

730

683

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

{ord(u"."): ord(u"_"),

733

ord(u"-"): ord(u"_")})

734

684

self.dbus_object_path = (dbus.ObjectPath

735

(u"/clients/" + client_object_name))

685

(u"/clients/"

686

+ self.name.replace(u".", u"_")))

736

687

DBusObjectWithProperties.__init__(self, self.bus,

737

688

self.dbus_object_path)

738

739

def _get_approvals_pending(self):

740

return self._approvals_pending

741

def _set_approvals_pending(self, value):

742

old_value = self._approvals_pending

743

self._approvals_pending = value

744

bval = bool(value)

745

if (hasattr(self, "dbus_object_path")

746

and bval is not bool(old_value)):

747

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

748

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

749

dbus_bool)

750

751

approvals_pending = property(_get_approvals_pending,

752

_set_approvals_pending)

753

del _get_approvals_pending, _set_approvals_pending

754

689

755

690

@staticmethod

756

691

def _datetime_to_dbus(dt, variant_level=0):

763

698

r = Client.enable(self)

764

699

if oldstate != self.enabled:

765

700

# Emit D-Bus signals

766

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

701

self.PropertyChanged(dbus.String(u"enabled"),

767

702

dbus.Boolean(True, variant_level=1))

768

703

self.PropertyChanged(

769

dbus.String(u"LastEnabled"),

704

dbus.String(u"last_enabled"),

770

705

self._datetime_to_dbus(self.last_enabled,

771

706

variant_level=1))

772

707

return r

776

711

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

777

712

if not quiet and oldstate != self.enabled:

778

713

# Emit D-Bus signal

779

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

714

self.PropertyChanged(dbus.String(u"enabled"),

780

715

dbus.Boolean(False, variant_level=1))

781

716

return r

782

717

794

729

self.checker_callback_tag = None

795

730

self.checker = None

796

731

# Emit D-Bus signal

797

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

732

self.PropertyChanged(dbus.String(u"checker_running"),

798

733

dbus.Boolean(False, variant_level=1))

799

734

if os.WIFEXITED(condition):

800

735

exitstatus = os.WEXITSTATUS(condition)

815

750

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

816

751

# Emit D-Bus signal

817

752

self.PropertyChanged(

818

dbus.String(u"LastCheckedOK"),

753

dbus.String(u"last_checked_ok"),

819

754

(self._datetime_to_dbus(self.last_checked_ok,

820

755

variant_level=1)))

821

756

return r

822

757

823

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

824

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

825

# Emit D-Bus signal

826

self.PropertyChanged(

827

dbus.String(u"LastApprovalRequest"),

828

(self._datetime_to_dbus(self.last_approval_request,

829

variant_level=1)))

830

return r

831

832

758

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

833

759

old_checker = self.checker

834

760

if self.checker is not None:

842

768

# Emit D-Bus signal

843

769

self.CheckerStarted(self.current_checker_command)

844

770

self.PropertyChanged(

845

dbus.String(u"CheckerRunning"),

771

dbus.String(u"checker_running"),

846

772

dbus.Boolean(True, variant_level=1))

847

773

return r

848

774

851

777

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

852

778

if (old_checker is not None

853

779

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

854

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

780

self.PropertyChanged(dbus.String(u"checker_running"),

855

781

dbus.Boolean(False, variant_level=1))

856

782

return r

857

858

def _reset_approved(self):

859

self._approved = None

860

return False

861

862

def approve(self, value=True):

863

self.send_changedstate()

864

self._approved = value

865

gobject.timeout_add(self._timedelta_to_milliseconds

866

(self.approval_duration),

867

self._reset_approved)

868

869

870

## D-Bus methods, signals & properties

783

784

## D-Bus methods & signals

871

785

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

872

786

873

## Signals

787

# CheckedOK - method

788

@dbus.service.method(_interface)

789

def CheckedOK(self):

790

return self.checked_ok()

874

791

875

792

# CheckerCompleted - signal

876

793

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

893

810

# GotSecret - signal

894

811

@dbus.service.signal(_interface)

895

812

def GotSecret(self):

896

"""D-Bus signal

897

Is sent after a successful transfer of secret from the Mandos

898

server to mandos-client

899

"""

813

"D-Bus signal"

900

814

pass

901

815

902

816

# Rejected - signal

903

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

904

def Rejected(self, reason):

817

@dbus.service.signal(_interface)

818

def Rejected(self):

905

819

"D-Bus signal"

906

820

pass

907

821

908

# NeedApproval - signal

909

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

910

def NeedApproval(self, timeout, default):

911

"D-Bus signal"

912

return self.need_approval()

913

914

## Methods

915

916

# Approve - method

917

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

918

def Approve(self, value):

919

self.approve(value)

920

921

# CheckedOK - method

922

@dbus.service.method(_interface)

923

def CheckedOK(self):

924

return self.checked_ok()

925

926

822

# Enable - method

927

823

@dbus.service.method(_interface)

928

824

def Enable(self):

946

842

def StopChecker(self):

947

843

self.stop_checker()

948

844

949

## Properties

950

951

# ApprovalPending - property

952

@dbus_service_property(_interface, signature=u"b", access=u"read")

953

def ApprovalPending_dbus_property(self):

954

return dbus.Boolean(bool(self.approvals_pending))

955

956

# ApprovedByDefault - property

957

@dbus_service_property(_interface, signature=u"b",

958

access=u"readwrite")

959

def ApprovedByDefault_dbus_property(self, value=None):

960

if value is None: # get

961

return dbus.Boolean(self.approved_by_default)

962

self.approved_by_default = bool(value)

963

# Emit D-Bus signal

964

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

965

dbus.Boolean(value, variant_level=1))

966

967

# ApprovalDelay - property

968

@dbus_service_property(_interface, signature=u"t",

969

access=u"readwrite")

970

def ApprovalDelay_dbus_property(self, value=None):

971

if value is None: # get

972

return dbus.UInt64(self.approval_delay_milliseconds())

973

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

974

# Emit D-Bus signal

975

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

976

dbus.UInt64(value, variant_level=1))

977

978

# ApprovalDuration - property

979

@dbus_service_property(_interface, signature=u"t",

980

access=u"readwrite")

981

def ApprovalDuration_dbus_property(self, value=None):

982

if value is None: # get

983

return dbus.UInt64(self._timedelta_to_milliseconds(

984

self.approval_duration))

985

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

986

# Emit D-Bus signal

987

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

988

dbus.UInt64(value, variant_level=1))

989

990

# Name - property

845

# name - property

991

846

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

992

def Name_dbus_property(self):

847

def name_dbus_property(self):

993

848

return dbus.String(self.name)

994

849

995

# Fingerprint - property

850

# fingerprint - property

996

851

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

997

def Fingerprint_dbus_property(self):

852

def fingerprint_dbus_property(self):

998

853

return dbus.String(self.fingerprint)

999

854

1000

# Host - property

855

# host - property

1001

856

@dbus_service_property(_interface, signature=u"s",

1002

857

access=u"readwrite")

1003

def Host_dbus_property(self, value=None):

858

def host_dbus_property(self, value=None):

1004

859

if value is None: # get

1005

860

return dbus.String(self.host)

1006

861

self.host = value

1007

862

# Emit D-Bus signal

1008

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

863

self.PropertyChanged(dbus.String(u"host"),

1009

864

dbus.String(value, variant_level=1))

1010

865

1011

# Created - property

866

# created - property

1012

867

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

1013

def Created_dbus_property(self):

868

def created_dbus_property(self):

1014

869

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

1015

870

1016

# LastEnabled - property

871

# last_enabled - property

1017

872

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

1018

def LastEnabled_dbus_property(self):

873

def last_enabled_dbus_property(self):

1019

874

if self.last_enabled is None:

1020

875

return dbus.String(u"")

1021

876

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

1022

877

1023

# Enabled - property

878

# enabled - property

1024

879

@dbus_service_property(_interface, signature=u"b",

1025

880

access=u"readwrite")

1026

def Enabled_dbus_property(self, value=None):

881

def enabled_dbus_property(self, value=None):

1027

882

if value is None: # get

1028

883

return dbus.Boolean(self.enabled)

1029

884

if value:

1031

886

else:

1032

887

self.disable()

1033

888

1034

# LastCheckedOK - property

889

# last_checked_ok - property

1035

890

@dbus_service_property(_interface, signature=u"s",

1036

891

access=u"readwrite")

1037

def LastCheckedOK_dbus_property(self, value=None):

892

def last_checked_ok_dbus_property(self, value=None):

1038

893

if value is not None:

1039

894

self.checked_ok()

1040

895

return

1043

898

return dbus.String(self._datetime_to_dbus(self

1044

899

.last_checked_ok))

1045

900

1046

# LastApprovalRequest - property

1047

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

1048

def LastApprovalRequest_dbus_property(self):

1049

if self.last_approval_request is None:

1050

return dbus.String(u"")

1051

return dbus.String(self.

1052

_datetime_to_dbus(self

1053

.last_approval_request))

1054

1055

# Timeout - property

901

# timeout - property

1056

902

@dbus_service_property(_interface, signature=u"t",

1057

903

access=u"readwrite")

1058

def Timeout_dbus_property(self, value=None):

904

def timeout_dbus_property(self, value=None):

1059

905

if value is None: # get

1060

906

return dbus.UInt64(self.timeout_milliseconds())

1061

907

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

1062

908

# Emit D-Bus signal

1063

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

909

self.PropertyChanged(dbus.String(u"timeout"),

1064

910

dbus.UInt64(value, variant_level=1))

1065

911

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

1066

912

return

1080

926

self.disable_initiator_tag = (gobject.timeout_add

1081

927

(time_to_die, self.disable))

1082

928

1083

# Interval - property

929

# interval - property

1084

930

@dbus_service_property(_interface, signature=u"t",

1085

931

access=u"readwrite")

1086

def Interval_dbus_property(self, value=None):

932

def interval_dbus_property(self, value=None):

1087

933

if value is None: # get

1088

934

return dbus.UInt64(self.interval_milliseconds())

1089

935

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

1090

936

# Emit D-Bus signal

1091

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

937

self.PropertyChanged(dbus.String(u"interval"),

1092

938

dbus.UInt64(value, variant_level=1))

1093

939

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

1094

940

return

1098

944

(value, self.start_checker))

1099

945

self.start_checker() # Start one now, too

1100

946

1101

# Checker - property

947

# checker - property

1102

948

@dbus_service_property(_interface, signature=u"s",

1103

949

access=u"readwrite")

1104

def Checker_dbus_property(self, value=None):

950

def checker_dbus_property(self, value=None):

1105

951

if value is None: # get

1106

952

return dbus.String(self.checker_command)

1107

953

self.checker_command = value

1108

954

# Emit D-Bus signal

1109

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

955

self.PropertyChanged(dbus.String(u"checker"),

1110

956

dbus.String(self.checker_command,

1111

957

variant_level=1))

1112

958

1113

# CheckerRunning - property

959

# checker_running - property

1114

960

@dbus_service_property(_interface, signature=u"b",

1115

961

access=u"readwrite")

1116

def CheckerRunning_dbus_property(self, value=None):

962

def checker_running_dbus_property(self, value=None):

1117

963

if value is None: # get

1118

964

return dbus.Boolean(self.checker is not None)

1119

965

if value:

1121

967

else:

1122

968

self.stop_checker()

1123

969

1124

# ObjectPath - property

970

# object_path - property

1125

971

@dbus_service_property(_interface, signature=u"o", access=u"read")

1126

def ObjectPath_dbus_property(self):

972

def object_path_dbus_property(self):

1127

973

return self.dbus_object_path # is already a dbus.ObjectPath

1128

974

1129

# Secret = property

975

# secret = property

1130

976

@dbus_service_property(_interface, signature=u"ay",

1131

977

access=u"write", byte_arrays=True)

1132

def Secret_dbus_property(self, value):

978

def secret_dbus_property(self, value):

1133

979

self.secret = str(value)

1134

980

1135

981

del _interface

1136

982

1137

983

1138

class ProxyClient(object):

1139

def __init__(self, child_pipe, fpr, address):

1140

self._pipe = child_pipe

1141

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

1142

if not self._pipe.recv():

1143

raise KeyError()

1144

1145

def __getattribute__(self, name):

1146

if(name == '_pipe'):

1147

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

1148

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

1149

data = self._pipe.recv()

1150

if data[0] == 'data':

1151

return data[1]

1152

if data[0] == 'function':

1153

def func(*args, **kwargs):

1154

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

1155

return self._pipe.recv()[1]

1156

return func

1157

1158

def __setattr__(self, name, value):

1159

if(name == '_pipe'):

1160

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

1161

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

1162

1163

1164

984

class ClientHandler(socketserver.BaseRequestHandler, object):

1165

985

"""A class to handle client connections.

1166

986

1168

988

Note: This will run in its own forked process."""

1169

989

1170

990

def handle(self):

1171

with contextlib.closing(self.server.child_pipe) as child_pipe:

1172

logger.info(u"TCP connection from: %s",

1173

unicode(self.client_address))

1174

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

1175

self.server.child_pipe.fileno())

1176

991

logger.info(u"TCP connection from: %s",

992

unicode(self.client_address))

993

logger.debug(u"IPC Pipe FD: %d", self.server.pipe[1])

994

# Open IPC pipe to parent process

995

with closing(os.fdopen(self.server.pipe[1], u"w", 1)) as ipc:

1177

996

session = (gnutls.connection

1178

997

.ClientSession(self.request,

1179

998

gnutls.connection

1180

999

.X509Credentials()))

1181

1000

1001

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

1002

logger.debug(u"Protocol version: %r", line)

1003

try:

1004

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

1005

raise RuntimeError

1006

except (ValueError, IndexError, RuntimeError), error:

1007

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

1008

return

1009

1182

1010

# Note: gnutls.connection.X509Credentials is really a

1183

1011

# generic GnuTLS certificate credentials object so long as

1184

1012

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

1185

1013

# here despite using OpenPGP certificates.

1186

1014

1187

1015

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

1188

1016

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

1189

1017

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

1195

1023

(gnutls.library.functions

1196

1024

.gnutls_priority_set_direct(session._c_object,

1197

1025

priority, None))

1198

1199

# Start communication using the Mandos protocol

1200

# Get protocol number

1201

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

1202

logger.debug(u"Protocol version: %r", line)

1203

try:

1204

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

1205

raise RuntimeError

1206

except (ValueError, IndexError, RuntimeError), error:

1207

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

1208

return

1209

1210

# Start GnuTLS connection

1026

1211

1027

try:

1212

1028

session.handshake()

1213

1029

except gnutls.errors.GNUTLSError, error:

1216

1032

# established. Just abandon the request.

1217

1033

return

1218

1034

logger.debug(u"Handshake succeeded")

1219

1220

approval_required = False

1221

1035

try:

1222

try:

1223

fpr = self.fingerprint(self.peer_certificate

1224

(session))

1225

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

1226

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

1227

return

1228

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

1229

1230

try:

1231

client = ProxyClient(child_pipe, fpr,

1232

self.client_address)

1233

except KeyError:

1234

return

1235

1236

if client.approval_delay:

1237

delay = client.approval_delay

1238

client.approvals_pending += 1

1239

approval_required = True

1240

1241

while True:

1242

if not client.enabled:

1243

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

1244

client.name)

1245

if self.server.use_dbus:

1246

# Emit D-Bus signal

1247

client.Rejected("Disabled")

1248

return

1249

1250

if client._approved or not client.approval_delay:

1251

#We are approved or approval is disabled

1252

break

1253

elif client._approved is None:

1254

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

1255

client.name)

1256

if self.server.use_dbus:

1257

# Emit D-Bus signal

1258

client.NeedApproval(

1259

client.approval_delay_milliseconds(),

1260

client.approved_by_default)

1261

else:

1262

logger.warning(u"Client %s was not approved",

1263

client.name)

1264

if self.server.use_dbus:

1265

# Emit D-Bus signal

1266

client.Rejected("Denied")

1267

return

1268

1269

#wait until timeout or approved

1270

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

1271

time = datetime.datetime.now()

1272

client.changedstate.acquire()

1273

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

1274

client.changedstate.release()

1275

time2 = datetime.datetime.now()

1276

if (time2 - time) >= delay:

1277

if not client.approved_by_default:

1278

logger.warning("Client %s timed out while"

1279

" waiting for approval",

1280

client.name)

1281

if self.server.use_dbus:

1282

# Emit D-Bus signal

1283

client.Rejected("Approval timed out")

1284

return

1285

else:

1286

break

1287

else:

1288

delay -= time2 - time

1289

1290

sent_size = 0

1291

while sent_size < len(client.secret):

1292

try:

1293

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

1294

except (gnutls.errors.GNUTLSError), error:

1295

logger.warning("gnutls send failed")

1296

return

1297

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

1298

sent, len(client.secret)

1299

- (sent_size + sent))

1300

sent_size += sent

1301

1302

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

1303

# bump the timeout as if seen

1304

client.checked_ok()

1305

if self.server.use_dbus:

1306

# Emit D-Bus signal

1307

client.GotSecret()

1036

fpr = self.fingerprint(self.peer_certificate(session))

1037

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

1038

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

1039

session.bye()

1040

return

1041

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

1308

1042

1309

finally:

1310

if approval_required:

1311

client.approvals_pending -= 1

1312

try:

1313

session.bye()

1314

except (gnutls.errors.GNUTLSError), error:

1315

logger.warning("GnuTLS bye failed")

1043

for c in self.server.clients:

1044

if c.fingerprint == fpr:

1045

client = c

1046

break

1047

else:

1048

ipc.write(u"NOTFOUND %s %s\n"

1049

% (fpr, unicode(self.client_address)))

1050

session.bye()

1051

return

1052

# Have to check if client.still_valid(), since it is

1053

# possible that the client timed out while establishing

1054

# the GnuTLS session.

1055

if not client.still_valid():

1056

ipc.write(u"INVALID %s\n" % client.name)

1057

session.bye()

1058

return

1059

ipc.write(u"SENDING %s\n" % client.name)

1060

sent_size = 0

1061

while sent_size < len(client.secret):

1062

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

1063

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

1064

sent, len(client.secret)

1065

- (sent_size + sent))

1066

sent_size += sent

1067

session.bye()

1316

1068

1317

1069

@staticmethod

1318

1070

def peer_certificate(session):

1378

1130

return hex_fpr

1379

1131

1380

1132

1381

class MultiprocessingMixIn(object):

1382

"""Like socketserver.ThreadingMixIn, but with multiprocessing"""

1383

def sub_process_main(self, request, address):

1384

try:

1385

self.finish_request(request, address)

1386

except:

1387

self.handle_error(request, address)

1388

self.close_request(request)

1389

1390

def process_request(self, request, address):

1391

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

1392

multiprocessing.Process(target = self.sub_process_main,

1393

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

1394

1395

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1396

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

1133

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

1134

"""Like socketserver.ForkingMixIn, but also pass a pipe."""

1397

1135

def process_request(self, request, client_address):

1398

1136

"""Overrides and wraps the original process_request().

1399

1137

1400

1138

This function creates a new pipe in self.pipe

1401

1139

"""

1402

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1403

1404

super(MultiprocessingMixInWithPipe,

1140

self.pipe = os.pipe()

1141

super(ForkingMixInWithPipe,

1405

1142

self).process_request(request, client_address)

1406

self.child_pipe.close()

1407

self.add_pipe(parent_pipe)

1408

1409

def add_pipe(self, parent_pipe):

1143

os.close(self.pipe[1]) # close write end

1144

self.add_pipe(self.pipe[0])

1145

def add_pipe(self, pipe):

1410

1146

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

1411

pass

1412

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1147

os.close(pipe)

1148

1149

1150

class IPv6_TCPServer(ForkingMixInWithPipe,

1414

1151

socketserver.TCPServer, object):

1415

1152

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

1416

1153

1501

1238

return socketserver.TCPServer.server_activate(self)

1502

1239

def enable(self):

1503

1240

self.enabled = True

1504

def add_pipe(self, parent_pipe):

1241

def add_pipe(self, pipe):

1505

1242

# Call "handle_ipc" for both data and EOF events

1506

gobject.io_add_watch(parent_pipe.fileno(),

1507

gobject.IO_IN | gobject.IO_HUP,

1508

functools.partial(self.handle_ipc,

1509

parent_pipe = parent_pipe))

1510

1511

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

1512

client_object=None):

1243

gobject.io_add_watch(pipe, gobject.IO_IN | gobject.IO_HUP,

1244

self.handle_ipc)

1245

def handle_ipc(self, source, condition, file_objects={}):

1513

1246

condition_names = {

1514

1247

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

1515

1248

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

1524

1257

for cond, name in

1525

1258

condition_names.iteritems()

1526

1259

if cond & condition)

1527

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

1528

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

1529

return False

1530

1531

# Read a request from the child

1532

request = parent_pipe.recv()

1533

command = request[0]

1534

1535

if command == 'init':

1536

fpr = request[1]

1537

address = request[2]

1538

1539

for c in self.clients:

1540

if c.fingerprint == fpr:

1541

client = c

1542

break

1543

else:

1544

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

1545

u"dress: %s", fpr, address)

1546

if self.use_dbus:

1547

# Emit D-Bus signal

1548

mandos_dbus_service.ClientNotFound(fpr, address[0])

1549

parent_pipe.send(False)

1550

return False

1551

1552

gobject.io_add_watch(parent_pipe.fileno(),

1553

gobject.IO_IN | gobject.IO_HUP,

1554

functools.partial(self.handle_ipc,

1555

parent_pipe = parent_pipe,

1556

client_object = client))

1557

parent_pipe.send(True)

1558

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

1559

return False

1560

if command == 'funcall':

1561

funcname = request[1]

1562

args = request[2]

1563

kwargs = request[3]

1564

1565

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

1566

1567

if command == 'getattr':

1568

attrname = request[1]

1569

if callable(client_object.__getattribute__(attrname)):

1570

parent_pipe.send(('function',))

1571

else:

1572

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

1573

1574

if command == 'setattr':

1575

attrname = request[1]

1576

value = request[2]

1577

setattr(client_object, attrname, value)

1578

1260

logger.debug(u"Handling IPC: FD = %d, condition = %s", source,

1261

conditions_string)

1262

1263

# Turn the pipe file descriptor into a Python file object

1264

if source not in file_objects:

1265

file_objects[source] = os.fdopen(source, u"r", 1)

1266

1267

# Read a line from the file object

1268

cmdline = file_objects[source].readline()

1269

if not cmdline: # Empty line means end of file

1270

# close the IPC pipe

1271

file_objects[source].close()

1272

del file_objects[source]

1273

1274

# Stop calling this function

1275

return False

1276

1277

logger.debug(u"IPC command: %r", cmdline)

1278

1279

# Parse and act on command

1280

cmd, args = cmdline.rstrip(u"\r\n").split(None, 1)

1281

1282

if cmd == u"NOTFOUND":

1283

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

1284

args)

1285

if self.use_dbus:

1286

# Emit D-Bus signal

1287

mandos_dbus_service.ClientNotFound(args)

1288

elif cmd == u"INVALID":

1289

for client in self.clients:

1290

if client.name == args:

1291

logger.warning(u"Client %s is invalid", args)

1292

if self.use_dbus:

1293

# Emit D-Bus signal

1294

client.Rejected()

1295

break

1296

else:

1297

logger.error(u"Unknown client %s is invalid", args)

1298

elif cmd == u"SENDING":

1299

for client in self.clients:

1300

if client.name == args:

1301

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

1302

client.checked_ok()

1303

if self.use_dbus:

1304

# Emit D-Bus signal

1305

client.GotSecret()

1306

break

1307

else:

1308

logger.error(u"Sending secret to unknown client %s",

1309

args)

1310

else:

1311

logger.error(u"Unknown IPC command: %r", cmdline)

1312

1313

# Keep calling this function

1579

1314

return True

1580

1315

1581

1316

1632

1367

def if_nametoindex(interface):

1633

1368

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

1634

1369

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

1635

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

1370

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

1636

1371

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1637

1372

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

1638

1373

interface))

1684

1419

parser.add_option("--debug", action=u"store_true",

1685

1420

help=u"Debug mode; run in foreground and log to"

1686

1421

u" terminal")

1687

parser.add_option("--debuglevel", type=u"string", metavar="LEVEL",

1688

help=u"Debug level for stdout output")

1689

1422

parser.add_option("--priority", type=u"string", help=u"GnuTLS"

1690

1423

u" priority string (see GnuTLS documentation)")

1691

1424

parser.add_option("--servicename", type=u"string",

1716

1449

u"servicename": u"Mandos",

1717

1450

u"use_dbus": u"True",

1718

1451

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1720

1452

}

1721

1453

1722

1454

# Parse config file for server-global settings

1739

1471

# options, if set.

1740

1472

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

1741

1473

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

1742

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

1474

u"use_dbus", u"use_ipv6"):

1743

1475

value = getattr(options, option)

1744

1476

if value is not None:

1745

1477

server_settings[option] = value

1754

1486

1755

1487

# For convenience

1756

1488

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1758

1489

use_dbus = server_settings[u"use_dbus"]

1759

1490

use_ipv6 = server_settings[u"use_ipv6"]

1760

1491

1492

if not debug:

1493

syslogger.setLevel(logging.WARNING)

1494

console.setLevel(logging.WARNING)

1495

1761

1496

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

1762

1497

syslogger.setFormatter(logging.Formatter

1763

1498

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

1769

1504

u"interval": u"5m",

1770

1505

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

1771

1506

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1774

1507

}

1775

1508

client_config = configparser.SafeConfigParser(client_defaults)

1776

1509

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

1782

1515

tcp_server = MandosServer((server_settings[u"address"],

1783

1516

server_settings[u"port"]),

1784

1517

ClientHandler,

1785

interface=(server_settings[u"interface"]

1786

or None),

1518

interface=server_settings[u"interface"],

1787

1519

use_ipv6=use_ipv6,

1788

1520

gnutls_priority=

1789

1521

server_settings[u"priority"],

1790

1522

use_dbus=use_dbus)

1791

if not debug:

1792

pidfilename = u"/var/run/mandos.pid"

1793

try:

1794

pidfile = open(pidfilename, u"w")

1795

except IOError:

1796

logger.error(u"Could not open file %r", pidfilename)

1523

pidfilename = u"/var/run/mandos.pid"

1524

try:

1525

pidfile = open(pidfilename, u"w")

1526

except IOError:

1527

logger.error(u"Could not open file %r", pidfilename)

1797

1528

1798

1529

try:

1799

1530

uid = pwd.getpwnam(u"_mandos").pw_uid

1816

1547

if error[0] != errno.EPERM:

1817

1548

raise error

1818

1549

1819

if not debug and not debuglevel:

1820

syslogger.setLevel(logging.WARNING)

1821

console.setLevel(logging.WARNING)

1822

if debuglevel:

1823

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

1824

syslogger.setLevel(level)

1825

console.setLevel(level)

1826

1550

# Enable all possible GnuTLS debugging

1827

1551

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1830

1552

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

1831

1553

# - GnuTLS manual

1832

1554

gnutls.library.functions.gnutls_global_set_log_level(11)

1837

1559

1838

1560

(gnutls.library.functions

1839

1561

.gnutls_global_set_log_function(debug_gnutls))

1840

1841

# Redirect stdin so all checkers get /dev/null

1842

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

1843

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

1844

if null > 2:

1845

os.close(null)

1846

else:

1847

# No console logging

1848

logger.removeHandler(console)

1849

1850

1562

1851

1563

global main_loop

1852

1564

# From the Avahi example code

1870

1582

if server_settings["interface"]:

1871

1583

service.interface = (if_nametoindex

1872

1584

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

1873

1874

if not debug:

1875

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

1876

daemon()

1877

1878

global multiprocessing_manager

1879

multiprocessing_manager = multiprocessing.Manager()

1880

1585

1881

1586

client_class = Client

1882

1587

if use_dbus:

1883

1588

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

1884

def client_config_items(config, section):

1885

special_settings = {

1886

"approved_by_default":

1887

lambda: config.getboolean(section,

1888

"approved_by_default"),

1889

}

1890

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

1891

try:

1892

yield (name, special_settings[name]())

1893

except KeyError:

1894

yield (name, value)

1895

1896

1589

tcp_server.clients.update(set(

1897

1590

client_class(name = section,

1898

config= dict(client_config_items(

1899

client_config, section)))

1591

config= dict(client_config.items(section)))

1900

1592

for section in client_config.sections()))

1901

1593

if not tcp_server.clients:

1902

1594

logger.warning(u"No clients defined")

1903

1595

1596

if debug:

1597

# Redirect stdin so all checkers get /dev/null

1598

null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

1599

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

1600

if null > 2:

1601

os.close(null)

1602

else:

1603

# No console logging

1604

logger.removeHandler(console)

1605

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

1606

daemon()

1607

1608

try:

1609

with closing(pidfile):

1610

pid = os.getpid()

1611

pidfile.write(str(pid) + "\n")

1612

del pidfile

1613

except IOError:

1614

logger.error(u"Could not write to file %r with PID %d",

1615

pidfilename, pid)

1616

except NameError:

1617

# "pidfile" was never created

1618

pass

1619

del pidfilename

1620

1904

1621

if not debug:

1905

try:

1906

with pidfile:

1907

pid = os.getpid()

1908

pidfile.write(str(pid) + "\n")

1909

del pidfile

1910

except IOError:

1911

logger.error(u"Could not write to file %r with PID %d",

1912

pidfilename, pid)

1913

except NameError:

1914

# "pidfile" was never created

1915

pass

1916

del pidfilename

1917

1918

1622

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

1919

1920

1623

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

1921

1624

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

1922

1625

1927

1630

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

1928

1631

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

1929

1632

1930

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

1931

def ClientAdded(self, objpath):

1633

@dbus.service.signal(_interface, signature=u"oa{sv}")

1634

def ClientAdded(self, objpath, properties):

1932

1635

"D-Bus signal"

1933

1636

pass

1934

1637

1935

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

1936

def ClientNotFound(self, fingerprint, address):

1638

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

1639

def ClientNotFound(self, fingerprint):

1937

1640

"D-Bus signal"

1938

1641

pass

1939

1642

1996

1699

for client in tcp_server.clients:

1997

1700

if use_dbus:

1998

1701

# Emit D-Bus signal

1999

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1702

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1703

client.GetAll(u""))

2000

1704

client.enable()

2001

1705

2002

1706

tcp_server.enable()