/mandos/trunk : revision 24.2.1

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

84

version = "1.0.14"

83

85

84

86

logger = logging.Logger(u'mandos')

85

87

syslogger = (logging.handlers.SysLogHandler

96

98

u' %(message)s'))

97

99

logger.addHandler(console)

98

100

101

multiprocessing_manager = multiprocessing.Manager()

102

99

103

class AvahiError(Exception):

100

104

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

101

105

self.value = value

242

246

enabled: bool()

243

247

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

244

248

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

245

until this client is invalid

249

until this client is disabled

246

250

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

247

251

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

248

252

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

256

260

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

257

261

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

258

262

current_checker_command: string; current running checker_command

263

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

264

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

265

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

259

266

"""

260

267

261

268

@staticmethod

272

279

def interval_milliseconds(self):

273

280

"Return the 'interval' attribute in milliseconds"

274

281

return self._timedelta_to_milliseconds(self.interval)

282

283

def approved_delay_milliseconds(self):

284

return self._timedelta_to_milliseconds(self.approved_delay)

275

285

276

286

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

277

287

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

290

300

if u"secret" in config:

291

301

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

292

302

elif u"secfile" in config:

293

with closing(open(os.path.expanduser

294

(os.path.expandvars

295

(config[u"secfile"])))) as secfile:

303

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

304

(config[u"secfile"])),

305

"rb") as secfile:

296

306

self.secret = secfile.read()

297

307

else:

308

#XXX Need to allow secret on demand!

298

309

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

299

310

% self.name)

300

311

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

312

323

self.checker_command = config[u"checker"]

313

324

self.current_checker_command = None

314

325

self.last_connect = None

315

326

self.approvals_pending = 0

327

self._approved = None

328

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

329

True)

330

self.approved_delay = string_to_delta(

331

config[u"approved_delay"])

332

self.approved_duration = string_to_delta(

333

config[u"approved_duration"])

334

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

335

336

def send_changedstate(self):

337

self.changedstate.acquire()

338

self.changedstate.notify_all()

339

self.changedstate.release()

340

316

341

def enable(self):

317

342

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

318

343

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

319

344

# Already enabled

320

345

return

346

self.send_changedstate()

321

347

self.last_enabled = datetime.datetime.utcnow()

322

348

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

323

349

# and every interval from then on.

324

350

self.checker_initiator_tag = (gobject.timeout_add

325

351

(self.interval_milliseconds(),

326

352

self.start_checker))

327

# Also start a new checker *right now*.

328

self.start_checker()

329

353

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

330

354

self.disable_initiator_tag = (gobject.timeout_add

331

355

(self.timeout_milliseconds(),

332

356

self.disable))

333

357

self.enabled = True

358

# Also start a new checker *right now*.

359

self.start_checker()

334

360

335

def disable(self):

361

def disable(self, quiet=True):

336

362

"""Disable this client."""

337

363

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

338

364

return False

339

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

365

if not quiet:

366

self.send_changedstate()

367

if not quiet:

368

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

340

369

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

341

370

gobject.source_remove(self.disable_initiator_tag)

342

371

self.disable_initiator_tag = None

394

423

# client would inevitably timeout, since no checker would get

395

424

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

396

425

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

397

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

398

# is as it should be.

426

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

427

# should be.

399

428

400

429

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

401

430

try:

466

495

logger.debug(u"Stopping checker for %(name)s", vars(self))

467

496

try:

468

497

os.kill(self.checker.pid, signal.SIGTERM)

469

#os.sleep(0.5)

498

#time.sleep(0.5)

470

499

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

471

500

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

472

501

except OSError, error:

473

502

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

474

503

raise

475

504

self.checker = None

476

477

def still_valid(self):

478

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

479

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

480

return False

481

now = datetime.datetime.utcnow()

482

if self.last_checked_ok is None:

483

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

484

else:

485

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

486

487

505

488

506

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

489

507

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

497

515

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

498

516

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

499

517

"""

518

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

519

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

520

if byte_arrays and signature != u"ay":

521

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

522

u" signature %r" % signature)

500

523

def decorator(func):

501

524

func._dbus_is_property = True

502

525

func._dbus_interface = dbus_interface

588

611

if prop._dbus_access == u"read":

589

612

raise DBusPropertyAccessException(property_name)

590

613

if prop._dbus_get_args_options[u"byte_arrays"]:

614

# The byte_arrays option is not supported yet on

615

# signatures other than "ay".

616

if prop._dbus_signature != u"ay":

617

raise ValueError

591

618

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

592

619

for byte in value))

593

620

prop(value)

625

652

"""Standard D-Bus method, overloaded to insert property tags.

626

653

"""

627

654

xmlstring = dbus.service.Object.Introspect(self, object_path,

628

connection)

629

document = xml.dom.minidom.parseString(xmlstring)

630

del xmlstring

631

def make_tag(document, name, prop):

632

e = document.createElement(u"property")

633

e.setAttribute(u"name", name)

634

e.setAttribute(u"type", prop._dbus_signature)

635

e.setAttribute(u"access", prop._dbus_access)

636

return e

637

for if_tag in document.getElementsByTagName(u"interface"):

638

for tag in (make_tag(document, name, prop)

639

for name, prop

640

in self._get_all_dbus_properties()

641

if prop._dbus_interface

642

== if_tag.getAttribute(u"name")):

643

if_tag.appendChild(tag)

644

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

645

document.unlink()

655

connection)

656

try:

657

document = xml.dom.minidom.parseString(xmlstring)

658

def make_tag(document, name, prop):

659

e = document.createElement(u"property")

660

e.setAttribute(u"name", name)

661

e.setAttribute(u"type", prop._dbus_signature)

662

e.setAttribute(u"access", prop._dbus_access)

663

return e

664

for if_tag in document.getElementsByTagName(u"interface"):

665

for tag in (make_tag(document, name, prop)

666

for name, prop

667

in self._get_all_dbus_properties()

668

if prop._dbus_interface

669

== if_tag.getAttribute(u"name")):

670

if_tag.appendChild(tag)

671

# Add the names to the return values for the

672

# "org.freedesktop.DBus.Properties" methods

673

if (if_tag.getAttribute(u"name")

674

== u"org.freedesktop.DBus.Properties"):

675

for cn in if_tag.getElementsByTagName(u"method"):

676

if cn.getAttribute(u"name") == u"Get":

677

for arg in cn.getElementsByTagName(u"arg"):

678

if (arg.getAttribute(u"direction")

679

== u"out"):

680

arg.setAttribute(u"name", u"value")

681

elif cn.getAttribute(u"name") == u"GetAll":

682

for arg in cn.getElementsByTagName(u"arg"):

683

if (arg.getAttribute(u"direction")

684

== u"out"):

685

arg.setAttribute(u"name", u"props")

686

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

687

document.unlink()

688

except (AttributeError, xml.dom.DOMException,

689

xml.parsers.expat.ExpatError), error:

690

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

691

error)

646

692

return xmlstring

647

693

648

694

685

731

variant_level=1))

686

732

return r

687

733

688

def disable(self, signal = True):

734

def disable(self, quiet = False):

689

735

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

690

r = Client.disable(self)

691

if signal and oldstate != self.enabled:

736

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

737

if not quiet and oldstate != self.enabled:

692

738

# Emit D-Bus signal

693

739

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

694

740

dbus.Boolean(False, variant_level=1))

759

805

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

760

806

dbus.Boolean(False, variant_level=1))

761

807

return r

762

763

## D-Bus methods & signals

808

809

def _reset_approved(self):

810

self._approved = None

811

return False

812

813

def approve(self, value=True):

814

self._approved = value

815

gobject.timeout_add(self._timedelta_to_milliseconds(self.approved_duration, self._reset_approved))

816

817

def approved_pending(self):

818

return self.approvals_pending > 0

819

820

821

## D-Bus methods, signals & properties

764

822

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

765

823

766

# CheckedOK - method

767

@dbus.service.method(_interface)

768

def CheckedOK(self):

769

return self.checked_ok()

824

## Signals

770

825

771

826

# CheckerCompleted - signal

772

827

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

786

841

"D-Bus signal"

787

842

pass

788

843

789

# ReceivedSecret - signal

844

# GotSecret - signal

790

845

@dbus.service.signal(_interface)

791

def ReceivedSecret(self):

846

def GotSecret(self):

792

847

"D-Bus signal"

793

pass

848

if self.approved_pending():

849

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

850

dbus.Boolean(False, variant_level=1))

794

851

795

852

# Rejected - signal

796

@dbus.service.signal(_interface)

797

def Rejected(self):

798

"D-Bus signal"

799

pass

853

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

854

def Rejected(self, reason):

855

"D-Bus signal"

856

if self.approved_pending():

857

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

858

dbus.Boolean(False, variant_level=1))

859

860

# NeedApproval - signal

861

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

862

def NeedApproval(self, timeout, default):

863

"D-Bus signal"

864

if not self.approved_pending():

865

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

866

dbus.Boolean(True, variant_level=1))

867

868

## Methods

869

870

# Approve - method

871

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

872

def Approve(self, value):

873

self.approve(value)

874

875

# CheckedOK - method

876

@dbus.service.method(_interface)

877

def CheckedOK(self):

878

return self.checked_ok()

800

879

801

880

# Enable - method

802

881

@dbus.service.method(_interface)

821

900

def StopChecker(self):

822

901

self.stop_checker()

823

902

903

## Properties

904

905

# approved_pending - property

906

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

907

def approved_pending_dbus_property(self):

908

return dbus.Boolean(self.approved_pending())

909

910

# approved_by_default - property

911

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

912

access=u"readwrite")

913

def approved_by_default_dbus_property(self):

914

return dbus.Boolean(self.approved_by_default)

915

916

# approved_delay - property

917

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

918

access=u"readwrite")

919

def approved_delay_dbus_property(self):

920

return dbus.UInt64(self.approved_delay_milliseconds())

921

922

# approved_duration - property

923

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

924

access=u"readwrite")

925

def approved_duration_dbus_property(self):

926

return dbus.UInt64(self._timedelta_to_milliseconds(

927

self.approved_duration))

928

824

929

# name - property

825

930

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

826

931

def name_dbus_property(self):

960

1065

del _interface

961

1066

962

1067

1068

class ProxyClient(object):

1069

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

1070

self._pipe = child_pipe

1071

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

1072

if not self._pipe.recv():

1073

raise KeyError()

1074

1075

def __getattribute__(self, name):

1076

if(name == '_pipe'):

1077

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

1078

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

1079

data = self._pipe.recv()

1080

if data[0] == 'data':

1081

return data[1]

1082

if data[0] == 'function':

1083

def func(*args, **kwargs):

1084

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

1085

return self._pipe.recv()[1]

1086

return func

1087

1088

def __setattr__(self, name, value):

1089

if(name == '_pipe'):

1090

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

1091

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

1092

1093

963

1094

class ClientHandler(socketserver.BaseRequestHandler, object):

964

1095

"""A class to handle client connections.

965

1096

967

1098

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

968

1099

969

1100

def handle(self):

970

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

971

unicode(self.client_address))

972

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

973

# Open IPC pipe to parent process

974

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

1101

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

1102

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

1103

unicode(self.client_address))

1104

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

1105

self.server.child_pipe.fileno())

1106

975

1107

session = (gnutls.connection

976

1108

.ClientSession(self.request,

977

1109

gnutls.connection

978

1110

.X509Credentials()))

979

980

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

981

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

982

try:

983

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

984

raise RuntimeError

985

except (ValueError, IndexError, RuntimeError), error:

986

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

987

return

988

1111

989

1112

# Note: gnutls.connection.X509Credentials is really a

990

1113

# generic GnuTLS certificate credentials object so long as

991

1114

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

992

1115

# here despite using OpenPGP certificates.

993

1116

994

1117

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

995

1118

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

996

1119

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

1002

1125

(gnutls.library.functions

1003

1126

.gnutls_priority_set_direct(session._c_object,

1004

1127

priority, None))

1005

1128

1129

# Start communication using the Mandos protocol

1130

# Get protocol number

1131

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

1132

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

1133

try:

1134

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

1135

raise RuntimeError

1136

except (ValueError, IndexError, RuntimeError), error:

1137

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

1138

return

1139

1140

# Start GnuTLS connection

1006

1141

try:

1007

1142

session.handshake()

1008

1143

except gnutls.errors.GNUTLSError, error:

1011

1146

# established. Just abandon the request.

1012

1147

return

1013

1148

logger.debug(u"Handshake succeeded")

1149

1150

approval_required = False

1014

1151

try:

1015

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

1016

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

1017

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

1018

session.bye()

1019

return

1020

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

1152

try:

1153

fpr = self.fingerprint(self.peer_certificate

1154

(session))

1155

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

1156

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

1157

return

1158

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

1159

1160

try:

1161

client = ProxyClient(child_pipe, fpr,

1162

self.client_address)

1163

except KeyError:

1164

return

1165

1166

if client.approved_delay:

1167

delay = client.approved_delay

1168

client.approvals_pending += 1

1169

approval_required = True

1170

1171

while True:

1172

if not client.enabled:

1173

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

1174

client.name)

1175

if self.server.use_dbus:

1176

# Emit D-Bus signal

1177

client.Rejected("Disabled")

1178

return

1179

1180

if client._approved or not client.approved_delay:

1181

#We are approved or approval is disabled

1182

break

1183

elif client._approved is None:

1184

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

1185

client.name)

1186

if self.server.use_dbus:

1187

# Emit D-Bus signal

1188

client.NeedApproval(

1189

client.approved_delay_milliseconds(),

1190

client.approved_by_default)

1191

else:

1192

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

1193

client.name)

1194

if self.server.use_dbus:

1195

# Emit D-Bus signal

1196

client.Rejected("Disapproved")

1197

return

1198

1199

#wait until timeout or approved

1200

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

1201

time = datetime.datetime.now()

1202

client.changedstate.acquire()

1203

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

1204

client.changedstate.release()

1205

time2 = datetime.datetime.now()

1206

if (time2 - time) >= delay:

1207

if not client.approved_by_default:

1208

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

1209

" waiting for approval",

1210

client.name)

1211

if self.server.use_dbus:

1212

# Emit D-Bus signal

1213

client.Rejected("Time out")

1214

return

1215

else:

1216

break

1217

else:

1218

delay -= time2 - time

1219

1220

sent_size = 0

1221

while sent_size < len(client.secret):

1222

# XXX handle session exception

1223

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

1224

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

1225

sent, len(client.secret)

1226

- (sent_size + sent))

1227

sent_size += sent

1228

1229

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

1230

# bump the timeout as if seen

1231

client.checked_ok()

1232

if self.server.use_dbus:

1233

# Emit D-Bus signal

1234

client.GotSecret()

1021

1235

1022

for c in self.server.clients:

1023

if c.fingerprint == fpr:

1024

client = c

1025

break

1026

else:

1027

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

1028

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

1029

session.bye()

1030

return

1031

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

1032

# possible that the client timed out while establishing

1033

# the GnuTLS session.

1034

if not client.still_valid():

1035

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

1036

session.bye()

1037

return

1038

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

1039

sent_size = 0

1040

while sent_size < len(client.secret):

1041

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

1042

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

1043

sent, len(client.secret)

1044

- (sent_size + sent))

1045

sent_size += sent

1046

session.bye()

1236

finally:

1237

if approval_required:

1238

client.approvals_pending -= 1

1239

session.bye()

1047

1240

1048

1241

@staticmethod

1049

1242

def peer_certificate(session):

1109

1302

return hex_fpr

1110

1303

1111

1304

1112

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

1113

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

1305

class MultiprocessingMixIn(object):

1306

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

1307

def sub_process_main(self, request, address):

1308

try:

1309

self.finish_request(request, address)

1310

except:

1311

self.handle_error(request, address)

1312

self.close_request(request)

1313

1314

def process_request(self, request, address):

1315

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

1316

multiprocessing.Process(target = self.sub_process_main,

1317

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

1318

1319

class MultiprocessingMixInWithPipe(MultiprocessingMixIn, object):

1320

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

1114

1321

def process_request(self, request, client_address):

1115

1322

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

1116

1323

1117

1324

This function creates a new pipe in self.pipe

1118

1325

"""

1119

self.pipe = os.pipe()

1120

super(ForkingMixInWithPipe,

1326

parent_pipe, self.child_pipe = multiprocessing.Pipe()

1327

1328

super(MultiprocessingMixInWithPipe,

1121

1329

self).process_request(request, client_address)

1122

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

1123

self.add_pipe(self.pipe[0])

1124

def add_pipe(self, pipe):

1330

self.add_pipe(parent_pipe)

1331

def add_pipe(self, parent_pipe):

1125

1332

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

1126

os.close(pipe)

1127

1128

1129

class IPv6_TCPServer(ForkingMixInWithPipe,

1333

pass

1334

1335

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1130

1336

socketserver.TCPServer, object):

1131

1337

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

1132

1338

1217

1423

return socketserver.TCPServer.server_activate(self)

1218

1424

def enable(self):

1219

1425

self.enabled = True

1220

def add_pipe(self, pipe):

1426

def add_pipe(self, parent_pipe):

1221

1427

# Call "handle_ipc" for both data and EOF events

1222

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

1223

self.handle_ipc)

1224

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

1428

gobject.io_add_watch(parent_pipe.fileno(),

1429

gobject.IO_IN | gobject.IO_HUP,

1430

functools.partial(self.handle_ipc,

1431

parent_pipe = parent_pipe))

1432

1433

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

1434

client_object=None):

1225

1435

condition_names = {

1226

1436

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

1227

1437

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

1239

1449

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

1240

1450

conditions_string)

1241

1451

1242

# Turn the pipe file descriptor into a Python file object

1243

if source not in file_objects:

1244

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

1452

# Read a request from the child

1453

request = parent_pipe.recv()

1454

command = request[0]

1245

1455

1246

# Read a line from the file object

1247

cmdline = file_objects[source].readline()

1248

if not cmdline: # Empty line means end of file

1249

# close the IPC pipe

1250

file_objects[source].close()

1251

del file_objects[source]

1252

1253

# Stop calling this function

1456

if command == 'init':

1457

fpr = request[1]

1458

address = request[2]

1459

1460

for c in self.clients:

1461

if c.fingerprint == fpr:

1462

client = c

1463

break

1464

else:

1465

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

1466

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

1467

if self.use_dbus:

1468

# Emit D-Bus signal

1469

mandos_dbus_service.ClientNotFound(fpr, address)

1470

parent_pipe.send(False)

1471

return False

1472

1473

gobject.io_add_watch(parent_pipe.fileno(),

1474

gobject.IO_IN | gobject.IO_HUP,

1475

functools.partial(self.handle_ipc,

1476

parent_pipe = parent_pipe,

1477

client_object = client))

1478

parent_pipe.send(True)

1479

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

1254

1480

return False

1255

1256

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

1257

1258

# Parse and act on command

1259

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

1260

1261

if cmd == u"NOTFOUND":

1262

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

1263

args)

1264

if self.use_dbus:

1265

# Emit D-Bus signal

1266

mandos_dbus_service.ClientNotFound(args)

1267

elif cmd == u"INVALID":

1268

for client in self.clients:

1269

if client.name == args:

1270

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

1271

if self.use_dbus:

1272

# Emit D-Bus signal

1273

client.Rejected()

1274

break

1275

else:

1276

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

1277

elif cmd == u"SENDING":

1278

for client in self.clients:

1279

if client.name == args:

1280

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

1281

client.checked_ok()

1282

if self.use_dbus:

1283

# Emit D-Bus signal

1284

client.ReceivedSecret()

1285

break

1286

else:

1287

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

1288

args)

1289

else:

1290

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

1291

1292

# Keep calling this function

1481

if command == 'funcall':

1482

funcname = request[1]

1483

args = request[2]

1484

kwargs = request[3]

1485

1486

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

1487

1488

if command == 'getattr':

1489

attrname = request[1]

1490

if callable(client_object.__getattribute__(attrname)):

1491

parent_pipe.send(('function',))

1492

else:

1493

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

1494

1495

if command == 'setattr':

1496

attrname = request[1]

1497

value = request[2]

1498

setattr(client_object, attrname, value)

1499

1293

1500

return True

1294

1501

1295

1502

1325

1532

elif suffix == u"w":

1326

1533

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

1327

1534

else:

1328

raise ValueError

1329

except (ValueError, IndexError):

1330

raise ValueError

1535

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

1536

except (ValueError, IndexError), e:

1537

raise ValueError(e.message)

1331

1538

timevalue += delta

1332

1539

return timevalue

1333

1540

1346

1553

def if_nametoindex(interface):

1347

1554

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

1348

1555

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

1349

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

1556

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

1350

1557

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1351

1558

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

1352

1559

interface))

1372

1579

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

1373

1580

if not stat.S_ISCHR(os.fstat(null).st_mode):

1374

1581

raise OSError(errno.ENODEV,

1375

u"/dev/null not a character device")

1582

u"%s not a character device"

1583

% os.path.devnull)

1376

1584

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

1377

1585

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

1378

1586

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

1482

1690

u"interval": u"5m",

1483

1691

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

1484

1692

u"host": u"",

1693

u"approved_delay": u"0s",

1694

u"approved_duration": u"1s",

1485

1695

}

1486

1696

client_config = configparser.SafeConfigParser(client_defaults)

1487

1697

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

1545

1755

bus = dbus.SystemBus()

1546

1756

# End of Avahi example code

1547

1757

if use_dbus:

1548

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

1758

try:

1759

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

1760

bus, do_not_queue=True)

1761

except dbus.exceptions.NameExistsException, e:

1762

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

1763

use_dbus = False

1764

server_settings[u"use_dbus"] = False

1765

tcp_server.use_dbus = False

1549

1766

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1550

1767

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

1551

1768

servicetype = u"_mandos._tcp",

1557

1774

client_class = Client

1558

1775

if use_dbus:

1559

1776

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

1777

def client_config_items(config, section):

1778

special_settings = {

1779

"approved_by_default":

1780

lambda: config.getboolean(section,

1781

"approved_by_default"),

1782

}

1783

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

1784

try:

1785

yield (name, special_settings[name]())

1786

except KeyError:

1787

yield (name, value)

1788

1560

1789

tcp_server.clients.update(set(

1561

1790

client_class(name = section,

1562

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

1791

config= dict(client_config_items(

1792

client_config, section)))

1563

1793

for section in client_config.sections()))

1564

1794

if not tcp_server.clients:

1565

1795

logger.warning(u"No clients defined")

1577

1807

daemon()

1578

1808

1579

1809

try:

1580

with closing(pidfile):

1810

with pidfile:

1581

1811

pid = os.getpid()

1582

1812

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

1583

1813

del pidfile

1589

1819

pass

1590

1820

del pidfilename

1591

1821

1592

def cleanup():

1593

"Cleanup function; run on exit"

1594

service.cleanup()

1595

1596

while tcp_server.clients:

1597

client = tcp_server.clients.pop()

1598

client.disable_hook = None

1599

client.disable()

1600

1601

atexit.register(cleanup)

1602

1603

1822

if not debug:

1604

1823

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

1605

1824

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

1612

1831

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

1613

1832

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

1614

1833

1615

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

1616

def ClientAdded(self, objpath, properties):

1834

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

1835

def ClientAdded(self, objpath):

1617

1836

"D-Bus signal"

1618

1837

pass

1619

1838

1620

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

1621

def ClientNotFound(self, fingerprint):

1839

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

1840

def ClientNotFound(self, fingerprint, address):

1622

1841

"D-Bus signal"

1623

1842

pass

1624

1843

1650

1869

tcp_server.clients.remove(c)

1651

1870

c.remove_from_connection()

1652

1871

# Don't signal anything except ClientRemoved

1653

c.disable(signal=False)

1872

c.disable(quiet=True)

1654

1873

# Emit D-Bus signal

1655

1874

self.ClientRemoved(object_path, c.name)

1656

1875

return

1657

raise KeyError

1876

raise KeyError(object_path)

1658

1877

1659

1878

del _interface

1660

1879

1661

1880

mandos_dbus_service = MandosDBusService()

1662

1881

1882

def cleanup():

1883

"Cleanup function; run on exit"

1884

service.cleanup()

1885

1886

while tcp_server.clients:

1887

client = tcp_server.clients.pop()

1888

if use_dbus:

1889

client.remove_from_connection()

1890

client.disable_hook = None

1891

# Don't signal anything except ClientRemoved

1892

client.disable(quiet=True)

1893

if use_dbus:

1894

# Emit D-Bus signal

1895

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

1896

client.name)

1897

1898

atexit.register(cleanup)

1899

1663

1900

for client in tcp_server.clients:

1664

1901

if use_dbus:

1665

1902

# Emit D-Bus signal

1666

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1667

client.GetAll(u""))

1903

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1668

1904

client.enable()

1669

1905

1670

1906

tcp_server.enable()

1688

1924

service.activate()

1689

1925

except dbus.exceptions.DBusException, error:

1690

1926

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

1927

cleanup()

1691

1928

sys.exit(1)

1692

1929

# End of Avahi example code

1693

1930

1700

1937

main_loop.run()

1701

1938

except AvahiError, error:

1702

1939

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

1940

cleanup()

1703

1941

sys.exit(1)

1704

1942

except KeyboardInterrupt:

1705

1943

if debug:

1706

1944

print >> sys.stderr

1707

1945

logger.debug(u"Server received KeyboardInterrupt")

1708

1946

logger.debug(u"Server exiting")

1947

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

1948

cleanup()

1709

1949

1710

1950

if __name__ == '__main__':

1711

1951

main()