/mandos/release : revision 237.7.11

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

from contextlib import closing

58

import contextlib

59

import struct

60

import fcntl

61

import functools

62

import cPickle as pickle

63

import multiprocessing

62

64

63

65

import dbus

64

66

import dbus.service

79

81

SO_BINDTODEVICE = None

80

82

81

83

82

version = "1.0.14"

84

version = "1.2.3"

83

85

86

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

84

87

logger = logging.Logger(u'mandos')

85

88

syslogger = (logging.handlers.SysLogHandler

86

89

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

154

157

u" after %i retries, exiting.",

155

158

self.rename_count)

156

159

raise AvahiServiceError(u"Too many renames")

157

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

160

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

158

161

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

159

unicode(self.name))

162

self.name)

160

163

syslogger.setFormatter(logging.Formatter

161

164

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

162

165

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

163

166

% self.name))

164

167

self.remove()

165

self.add()

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)

166

174

self.rename_count += 1

167

175

def remove(self):

168

176

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

191

199

self.group.Commit()

192

200

def entry_group_state_changed(self, state, error):

193

201

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

194

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

202

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

195

203

196

204

if state == avahi.ENTRY_GROUP_ESTABLISHED:

197

205

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

198

206

elif state == avahi.ENTRY_GROUP_COLLISION:

199

logger.warning(u"Zeroconf service name collision.")

207

logger.info(u"Zeroconf service name collision.")

200

208

self.rename()

201

209

elif state == avahi.ENTRY_GROUP_FAILURE:

202

210

logger.critical(u"Avahi: Error in group state changed %s",

210

218

self.group = None

211

219

def server_state_changed(self, state):

212

220

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

221

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

213

222

if state == avahi.SERVER_COLLISION:

214

223

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

215

224

self.remove()

231

240

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

232

241

233

242

Attributes:

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)

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

248

246

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

249

247

to see if the client lives.

250

248

'None' if no process is running.

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

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

256

252

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

257

253

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

258

256

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.

259

273

"""

260

274

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

261

280

@staticmethod

262

281

def _timedelta_to_milliseconds(td):

263

282

"Convert a datetime.timedelta() to milliseconds"

272

291

def interval_milliseconds(self):

273

292

"Return the 'interval' attribute in milliseconds"

274

293

return self._timedelta_to_milliseconds(self.interval)

294

295

def approval_delay_milliseconds(self):

296

return self._timedelta_to_milliseconds(self.approval_delay)

275

297

276

298

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

277

299

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

290

312

if u"secret" in config:

291

313

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

292

314

elif u"secfile" in config:

293

with closing(open(os.path.expanduser

294

(os.path.expandvars

295

(config[u"secfile"])),

296

"rb")) as secfile:

315

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

316

(config[u"secfile"])),

317

"rb") as secfile:

297

318

self.secret = secfile.read()

298

319

else:

299

320

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

301

322

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

302

323

self.created = datetime.datetime.utcnow()

303

324

self.enabled = False

325

self.last_approval_request = None

304

326

self.last_enabled = None

305

327

self.last_checked_ok = None

306

328

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

313

335

self.checker_command = config[u"checker"]

314

336

self.current_checker_command = None

315

337

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())

316

347

348

def send_changedstate(self):

349

self.changedstate.acquire()

350

self.changedstate.notify_all()

351

self.changedstate.release()

352

317

353

def enable(self):

318

354

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

319

355

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

320

356

# Already enabled

321

357

return

358

self.send_changedstate()

322

359

self.last_enabled = datetime.datetime.utcnow()

323

360

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

324

361

# and every interval from then on.

338

375

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

339

376

return False

340

377

if not quiet:

378

self.send_changedstate()

379

if not quiet:

341

380

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

342

381

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

343

382

gobject.source_remove(self.disable_initiator_tag)

385

424

(self.timeout_milliseconds(),

386

425

self.disable))

387

426

427

def need_approval(self):

428

self.last_approval_request = datetime.datetime.utcnow()

429

388

430

def start_checker(self):

389

431

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

390

432

396

438

# client would inevitably timeout, since no checker would get

397

439

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

398

440

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

399

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

400

# is as it should be.

441

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

442

# should be.

401

443

402

444

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

403

445

try:

419

461

command = self.checker_command % self.host

420

462

except TypeError:

421

463

# Escape attributes for the shell

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())

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

428

472

try:

429

473

command = self.checker_command % escaped_attrs

430

474

except TypeError, error:

475

519

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

476

520

raise

477

521

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

489

522

490

523

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

491

524

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

499

532

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

500

533

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

501

534

"""

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)

502

540

def decorator(func):

503

541

func._dbus_is_property = True

504

542

func._dbus_interface = dbus_interface

590

628

if prop._dbus_access == u"read":

591

629

raise DBusPropertyAccessException(property_name)

592

630

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

593

635

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

594

636

for byte in value))

595

637

prop(value)

674

716

dbus_object_path: dbus.ObjectPath

675

717

bus: dbus.SystemBus()

676

718

"""

719

720

runtime_expansions = (Client.runtime_expansions

721

+ (u"dbus_object_path",))

722

677

723

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

678

724

679

725

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

726

self._approvals_pending = 0

680

727

self.bus = bus

681

728

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

682

729

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

683

730

# the D-Bus

731

client_object_name = unicode(self.name).translate(

732

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

733

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

684

734

self.dbus_object_path = (dbus.ObjectPath

685

(u"/clients/"

686

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

735

(u"/clients/" + client_object_name))

687

736

DBusObjectWithProperties.__init__(self, self.bus,

688

737

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

689

754

690

755

@staticmethod

691

756

def _datetime_to_dbus(dt, variant_level=0):

698

763

r = Client.enable(self)

699

764

if oldstate != self.enabled:

700

765

# Emit D-Bus signals

701

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

766

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

702

767

dbus.Boolean(True, variant_level=1))

703

768

self.PropertyChanged(

704

dbus.String(u"last_enabled"),

769

dbus.String(u"LastEnabled"),

705

770

self._datetime_to_dbus(self.last_enabled,

706

771

variant_level=1))

707

772

return r

711

776

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

712

777

if not quiet and oldstate != self.enabled:

713

778

# Emit D-Bus signal

714

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

779

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

715

780

dbus.Boolean(False, variant_level=1))

716

781

return r

717

782

729

794

self.checker_callback_tag = None

730

795

self.checker = None

731

796

# Emit D-Bus signal

732

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

797

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

733

798

dbus.Boolean(False, variant_level=1))

734

799

if os.WIFEXITED(condition):

735

800

exitstatus = os.WEXITSTATUS(condition)

750

815

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

751

816

# Emit D-Bus signal

752

817

self.PropertyChanged(

753

dbus.String(u"last_checked_ok"),

818

dbus.String(u"LastCheckedOK"),

754

819

(self._datetime_to_dbus(self.last_checked_ok,

755

820

variant_level=1)))

756

821

return r

757

822

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

758

832

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

759

833

old_checker = self.checker

760

834

if self.checker is not None:

768

842

# Emit D-Bus signal

769

843

self.CheckerStarted(self.current_checker_command)

770

844

self.PropertyChanged(

771

dbus.String(u"checker_running"),

845

dbus.String(u"CheckerRunning"),

772

846

dbus.Boolean(True, variant_level=1))

773

847

return r

774

848

777

851

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

778

852

if (old_checker is not None

779

853

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

780

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

854

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

781

855

dbus.Boolean(False, variant_level=1))

782

856

return r

783

784

## D-Bus methods & signals

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

785

871

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

786

872

787

# CheckedOK - method

788

@dbus.service.method(_interface)

789

def CheckedOK(self):

790

return self.checked_ok()

873

## Signals

791

874

792

875

# CheckerCompleted - signal

793

876

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

810

893

# GotSecret - signal

811

894

@dbus.service.signal(_interface)

812

895

def GotSecret(self):

813

"D-Bus signal"

896

"""D-Bus signal

897

Is sent after a successful transfer of secret from the Mandos

898

server to mandos-client

899

"""

814

900

pass

815

901

816

902

# Rejected - signal

817

@dbus.service.signal(_interface)

818

def Rejected(self):

903

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

904

def Rejected(self, reason):

819

905

"D-Bus signal"

820

906

pass

821

907

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

822

926

# Enable - method

823

927

@dbus.service.method(_interface)

824

928

def Enable(self):

842

946

def StopChecker(self):

843

947

self.stop_checker()

844

948

845

# name - property

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

846

991

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

847

def name_dbus_property(self):

992

def Name_dbus_property(self):

848

993

return dbus.String(self.name)

849

994

850

# fingerprint - property

995

# Fingerprint - property

851

996

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

852

def fingerprint_dbus_property(self):

997

def Fingerprint_dbus_property(self):

853

998

return dbus.String(self.fingerprint)

854

999

855

# host - property

1000

# Host - property

856

1001

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

857

1002

access=u"readwrite")

858

def host_dbus_property(self, value=None):

1003

def Host_dbus_property(self, value=None):

859

1004

if value is None: # get

860

1005

return dbus.String(self.host)

861

1006

self.host = value

862

1007

# Emit D-Bus signal

863

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

1008

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

864

1009

dbus.String(value, variant_level=1))

865

1010

866

# created - property

1011

# Created - property

867

1012

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

868

def created_dbus_property(self):

1013

def Created_dbus_property(self):

869

1014

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

870

1015

871

# last_enabled - property

1016

# LastEnabled - property

872

1017

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

873

def last_enabled_dbus_property(self):

1018

def LastEnabled_dbus_property(self):

874

1019

if self.last_enabled is None:

875

1020

return dbus.String(u"")

876

1021

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

877

1022

878

# enabled - property

1023

# Enabled - property

879

1024

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

880

1025

access=u"readwrite")

881

def enabled_dbus_property(self, value=None):

1026

def Enabled_dbus_property(self, value=None):

882

1027

if value is None: # get

883

1028

return dbus.Boolean(self.enabled)

884

1029

if value:

886

1031

else:

887

1032

self.disable()

888

1033

889

# last_checked_ok - property

1034

# LastCheckedOK - property

890

1035

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

891

1036

access=u"readwrite")

892

def last_checked_ok_dbus_property(self, value=None):

1037

def LastCheckedOK_dbus_property(self, value=None):

893

1038

if value is not None:

894

1039

self.checked_ok()

895

1040

return

898

1043

return dbus.String(self._datetime_to_dbus(self

899

1044

.last_checked_ok))

900

1045

901

# timeout - property

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

902

1056

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

903

1057

access=u"readwrite")

904

def timeout_dbus_property(self, value=None):

1058

def Timeout_dbus_property(self, value=None):

905

1059

if value is None: # get

906

1060

return dbus.UInt64(self.timeout_milliseconds())

907

1061

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

908

1062

# Emit D-Bus signal

909

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

1063

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

910

1064

dbus.UInt64(value, variant_level=1))

911

1065

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

912

1066

return

926

1080

self.disable_initiator_tag = (gobject.timeout_add

927

1081

(time_to_die, self.disable))

928

1082

929

# interval - property

1083

# Interval - property

930

1084

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

931

1085

access=u"readwrite")

932

def interval_dbus_property(self, value=None):

1086

def Interval_dbus_property(self, value=None):

933

1087

if value is None: # get

934

1088

return dbus.UInt64(self.interval_milliseconds())

935

1089

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

936

1090

# Emit D-Bus signal

937

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

1091

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

938

1092

dbus.UInt64(value, variant_level=1))

939

1093

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

940

1094

return

944

1098

(value, self.start_checker))

945

1099

self.start_checker() # Start one now, too

946

1100

947

# checker - property

1101

# Checker - property

948

1102

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

949

1103

access=u"readwrite")

950

def checker_dbus_property(self, value=None):

1104

def Checker_dbus_property(self, value=None):

951

1105

if value is None: # get

952

1106

return dbus.String(self.checker_command)

953

1107

self.checker_command = value

954

1108

# Emit D-Bus signal

955

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

1109

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

956

1110

dbus.String(self.checker_command,

957

1111

variant_level=1))

958

1112

959

# checker_running - property

1113

# CheckerRunning - property

960

1114

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

961

1115

access=u"readwrite")

962

def checker_running_dbus_property(self, value=None):

1116

def CheckerRunning_dbus_property(self, value=None):

963

1117

if value is None: # get

964

1118

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

965

1119

if value:

967

1121

else:

968

1122

self.stop_checker()

969

1123

970

# object_path - property

1124

# ObjectPath - property

971

1125

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

972

def object_path_dbus_property(self):

1126

def ObjectPath_dbus_property(self):

973

1127

return self.dbus_object_path # is already a dbus.ObjectPath

974

1128

975

# secret = property

1129

# Secret = property

976

1130

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

977

1131

access=u"write", byte_arrays=True)

978

def secret_dbus_property(self, value):

1132

def Secret_dbus_property(self, value):

979

1133

self.secret = str(value)

980

1134

981

1135

del _interface

982

1136

983

1137

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

984

1164

class ClientHandler(socketserver.BaseRequestHandler, object):

985

1165

"""A class to handle client connections.

986

1166

988

1168

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

989

1169

990

1170

def handle(self):

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:

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

996

1177

session = (gnutls.connection

997

1178

.ClientSession(self.request,

998

1179

gnutls.connection

999

1180

.X509Credentials()))

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

1181

1010

1182

# Note: gnutls.connection.X509Credentials is really a

1011

1183

# generic GnuTLS certificate credentials object so long as

1012

1184

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

1013

1185

# here despite using OpenPGP certificates.

1014

1186

1015

1187

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

1016

1188

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

1017

1189

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

1023

1195

(gnutls.library.functions

1024

1196

.gnutls_priority_set_direct(session._c_object,

1025

1197

priority, None))

1026

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

1027

1211

try:

1028

1212

session.handshake()

1029

1213

except gnutls.errors.GNUTLSError, error:

1032

1216

# established. Just abandon the request.

1033

1217

return

1034

1218

logger.debug(u"Handshake succeeded")

1219

1220

approval_required = False

1035

1221

try:

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)

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()

1042

1308

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()

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")

1068

1316

1069

1317

@staticmethod

1070

1318

def peer_certificate(session):

1130

1378

return hex_fpr

1131

1379

1132

1380

1133

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

1134

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

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 """

1135

1397

def process_request(self, request, client_address):

1136

1398

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

1137

1399

1138

1400

This function creates a new pipe in self.pipe

1139

1401

"""

1140

self.pipe = os.pipe()

1141

super(ForkingMixInWithPipe,

1402

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1403

1404

super(MultiprocessingMixInWithPipe,

1142

1405

self).process_request(request, client_address)

1143

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

1144

self.add_pipe(self.pipe[0])

1145

def add_pipe(self, pipe):

1406

self.child_pipe.close()

1407

self.add_pipe(parent_pipe)

1408

1409

def add_pipe(self, parent_pipe):

1146

1410

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

1147

os.close(pipe)

1148

1149

1150

class IPv6_TCPServer(ForkingMixInWithPipe,

1411

pass

1412

1413

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1151

1414

socketserver.TCPServer, object):

1152

1415

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

1153

1416

1238

1501

return socketserver.TCPServer.server_activate(self)

1239

1502

def enable(self):

1240

1503

self.enabled = True

1241

def add_pipe(self, pipe):

1504

def add_pipe(self, parent_pipe):

1242

1505

# Call "handle_ipc" for both data and EOF events

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={}):

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):

1246

1513

condition_names = {

1247

1514

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

1248

1515

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

1257

1524

for cond, name in

1258

1525

condition_names.iteritems()

1259

1526

if cond & condition)

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

fpr, address = args.split(None, 1)

1284

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

1285

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

1286

if self.use_dbus:

1287

# Emit D-Bus signal

1288

mandos_dbus_service.ClientNotFound(fpr, address)

1289

elif cmd == u"INVALID":

1290

for client in self.clients:

1291

if client.name == args:

1292

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

1293

if self.use_dbus:

1294

# Emit D-Bus signal

1295

client.Rejected()

1296

break

1297

else:

1298

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

1299

elif cmd == u"SENDING":

1300

for client in self.clients:

1301

if client.name == args:

1302

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

1303

client.checked_ok()

1304

if self.use_dbus:

1305

# Emit D-Bus signal

1306

client.GotSecret()

1307

break

1308

else:

1309

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

1310

args)

1311

else:

1312

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

1313

1314

# Keep calling this function

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

1315

1579

return True

1316

1580

1317

1581

1368

1632

def if_nametoindex(interface):

1369

1633

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

1370

1634

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

1371

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

1635

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

1372

1636

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1373

1637

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

1374

1638

interface))

1420

1684

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

1421

1685

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

1422

1686

u" terminal")

1687

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

1688

help=u"Debug level for stdout output")

1423

1689

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

1424

1690

u" priority string (see GnuTLS documentation)")

1425

1691

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

1450

1716

u"servicename": u"Mandos",

1451

1717

u"use_dbus": u"True",

1452

1718

u"use_ipv6": u"True",

1719

u"debuglevel": u"",

1453

1720

}

1454

1721

1455

1722

# Parse config file for server-global settings

1472

1739

# options, if set.

1473

1740

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

1474

1741

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

1475

u"use_dbus", u"use_ipv6"):

1742

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

1476

1743

value = getattr(options, option)

1477

1744

if value is not None:

1478

1745

server_settings[option] = value

1487

1754

1488

1755

# For convenience

1489

1756

debug = server_settings[u"debug"]

1757

debuglevel = server_settings[u"debuglevel"]

1490

1758

use_dbus = server_settings[u"use_dbus"]

1491

1759

use_ipv6 = server_settings[u"use_ipv6"]

1492

1493

if not debug:

1494

syslogger.setLevel(logging.WARNING)

1495

console.setLevel(logging.WARNING)

1496

1760

1497

1761

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

1498

1762

syslogger.setFormatter(logging.Formatter

1499

1763

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

1505

1769

u"interval": u"5m",

1506

1770

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

1507

1771

u"host": u"",

1772

u"approval_delay": u"0s",

1773

u"approval_duration": u"1s",

1508

1774

}

1509

1775

client_config = configparser.SafeConfigParser(client_defaults)

1510

1776

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

1516

1782

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

1517

1783

server_settings[u"port"]),

1518

1784

ClientHandler,

1519

interface=server_settings[u"interface"],

1785

interface=(server_settings[u"interface"]

1786

or None),

1520

1787

use_ipv6=use_ipv6,

1521

1788

gnutls_priority=

1522

1789

server_settings[u"priority"],

1523

1790

use_dbus=use_dbus)

1524

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

1525

try:

1526

pidfile = open(pidfilename, u"w")

1527

except IOError:

1528

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

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)

1529

1797

1530

1798

try:

1531

1799

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

1548

1816

if error[0] != errno.EPERM:

1549

1817

raise error

1550

1818

1551

# Enable all possible GnuTLS debugging

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

1552

1827

if debug:

1828

# Enable all possible GnuTLS debugging

1829

1553

1830

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

1554

1831

# - GnuTLS manual

1555

1832

gnutls.library.functions.gnutls_global_set_log_level(11)

1560

1837

1561

1838

(gnutls.library.functions

1562

1839

.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

# Need to fork before connecting to D-Bus

1851

if not debug:

1852

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

1853

daemon()

1563

1854

1564

1855

global main_loop

1565

1856

# From the Avahi example code

1584

1875

service.interface = (if_nametoindex

1585

1876

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

1586

1877

1878

global multiprocessing_manager

1879

multiprocessing_manager = multiprocessing.Manager()

1880

1587

1881

client_class = Client

1588

1882

if use_dbus:

1589

1883

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

1590

1896

tcp_server.clients.update(set(

1591

1897

client_class(name = section,

1592

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

1898

config= dict(client_config_items(

1899

client_config, section)))

1593

1900

for section in client_config.sections()))

1594

1901

if not tcp_server.clients:

1595

1902

logger.warning(u"No clients defined")

1596

1597

if debug:

1598

# Redirect stdin so all checkers get /dev/null

1599

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

1600

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

1601

if null > 2:

1602

os.close(null)

1603

else:

1604

# No console logging

1605

logger.removeHandler(console)

1606

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

1607

daemon()

1608

1609

try:

1610

with closing(pidfile):

1611

pid = os.getpid()

1612

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

1613

del pidfile

1614

except IOError:

1615

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

1616

pidfilename, pid)

1617

except NameError:

1618

# "pidfile" was never created

1619

pass

1620

del pidfilename

1621

1903

1622

1904

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

1623

1918

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

1919

1624

1920

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

1625

1921

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

1626

1922

1631

1927

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

1632

1928

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

1633

1929

1634

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

1635

def ClientAdded(self, objpath, properties):

1930

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

1931

def ClientAdded(self, objpath):

1636

1932

"D-Bus signal"

1637

1933

pass

1638

1934

1700

1996

for client in tcp_server.clients:

1701

1997

if use_dbus:

1702

1998

# Emit D-Bus signal

1703

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1704

client.GetAll(u""))

1999

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1705

2000

client.enable()

1706

2001

1707

2002

tcp_server.enable()