/mandos/release : revision 237.2.151

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 select

64

62

65

63

import dbus

66

64

import dbus.service

81

79

SO_BINDTODEVICE = None

82

80

83

81

84

version = "1.0.14"

82

version = "1.0.12"

85

83

86

84

logger = logging.Logger(u'mandos')

87

85

syslogger = (logging.handlers.SysLogHandler

193

191

self.group.Commit()

194

192

def entry_group_state_changed(self, state, error):

195

193

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

196

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

194

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

197

195

198

196

if state == avahi.ENTRY_GROUP_ESTABLISHED:

199

197

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

212

210

self.group = None

213

211

def server_state_changed(self, state):

214

212

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

215

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

216

213

if state == avahi.SERVER_COLLISION:

217

214

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

218

215

self.remove()

245

242

enabled: bool()

246

243

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

247

244

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

248

until this client is disabled

245

until this client is invalid

249

246

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

250

247

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

251

248

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

293

290

if u"secret" in config:

294

291

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

295

292

elif u"secfile" in config:

296

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

297

(config[u"secfile"])),

298

"rb") as secfile:

293

with closing(open(os.path.expanduser

294

(os.path.expandvars

295

(config[u"secfile"])),

296

"rb")) as secfile:

299

297

self.secret = secfile.read()

300

298

else:

301

299

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

327

325

self.checker_initiator_tag = (gobject.timeout_add

328

326

(self.interval_milliseconds(),

329

327

self.start_checker))

328

# Also start a new checker *right now*.

329

self.start_checker()

330

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

331

self.disable_initiator_tag = (gobject.timeout_add

332

(self.timeout_milliseconds(),

333

self.disable))

334

self.enabled = True

335

# Also start a new checker *right now*.

336

self.start_checker()

337

335

338

def disable(self, quiet=True):

336

def disable(self):

339

337

"""Disable this client."""

340

338

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

341

339

return False

342

if not quiet:

343

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

340

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

344

341

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

345

342

gobject.source_remove(self.disable_initiator_tag)

346

343

self.disable_initiator_tag = None

398

395

# client would inevitably timeout, since no checker would get

399

396

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

400

397

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

401

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

402

# should be.

398

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

399

# is as it should be.

403

400

404

401

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

405

402

try:

470

467

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

471

468

try:

472

469

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

473

#time.sleep(0.5)

470

#os.sleep(0.5)

474

471

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

475

472

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

476

473

except OSError, error:

477

474

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

478

475

raise

479

476

self.checker = None

477

478

def still_valid(self):

479

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

480

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

481

return False

482

now = datetime.datetime.utcnow()

483

if self.last_checked_ok is None:

484

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

485

else:

486

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

480

487

481

488

482

489

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

491

498

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

492

499

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

493

500

"""

494

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

495

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

496

if byte_arrays and signature != u"ay":

497

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

498

u" signature %r" % signature)

499

501

def decorator(func):

500

502

func._dbus_is_property = True

501

503

func._dbus_interface = dbus_interface

587

589

if prop._dbus_access == u"read":

588

590

raise DBusPropertyAccessException(property_name)

589

591

if prop._dbus_get_args_options[u"byte_arrays"]:

590

# The byte_arrays option is not supported yet on

591

# signatures other than "ay".

592

if prop._dbus_signature != u"ay":

593

raise ValueError

594

592

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

595

593

for byte in value))

596

594

prop(value)

707

705

variant_level=1))

708

706

return r

709

707

710

def disable(self, quiet = False):

708

def disable(self, signal = True):

711

709

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

712

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

713

if not quiet and oldstate != self.enabled:

710

r = Client.disable(self)

711

if signal and oldstate != self.enabled:

714

712

# Emit D-Bus signal

715

713

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

716

714

dbus.Boolean(False, variant_level=1))

782

780

dbus.Boolean(False, variant_level=1))

783

781

return r

784

782

785

## D-Bus methods, signals & properties

783

## D-Bus methods & signals

786

784

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

787

785

788

## Signals

786

# CheckedOK - method

787

@dbus.service.method(_interface)

788

def CheckedOK(self):

789

return self.checked_ok()

789

790

791

# CheckerCompleted - signal

791

792

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

817

818

"D-Bus signal"

818

819

pass

819

820

## Methods

821

822

# CheckedOK - method

823

@dbus.service.method(_interface)

824

def CheckedOK(self):

825

return self.checked_ok()

826

827

821

# Enable - method

828

822

@dbus.service.method(_interface)

829

823

def Enable(self):

847

841

def StopChecker(self):

848

842

self.stop_checker()

849

843

850

## Properties

851

852

844

# name - property

853

845

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

854

846

def name_dbus_property(self):

997

989

def handle(self):

998

990

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

999

991

unicode(self.client_address))

1000

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

1001

self.server.child_pipe[1].fileno())

992

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

1002

993

# Open IPC pipe to parent process

1003

with contextlib.nested(self.server.child_pipe[1],

1004

self.server.parent_pipe[0]

1005

) as (ipc, ipc_return):

994

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

1006

995

session = (gnutls.connection

1007

996

.ClientSession(self.request,

1008

997

gnutls.connection

1009

998

.X509Credentials()))

1010

999

1000

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

1001

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

1002

try:

1003

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

1004

raise RuntimeError

1005

except (ValueError, IndexError, RuntimeError), error:

1006

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

1007

return

1008

1011

1009

# Note: gnutls.connection.X509Credentials is really a

1012

1010

# generic GnuTLS certificate credentials object so long as

1013

1011

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

1025

1023

.gnutls_priority_set_direct(session._c_object,

1026

1024

priority, None))

1027

1025

1028

# Start communication using the Mandos protocol

1029

# Get protocol number

1030

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

1031

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

1032

try:

1033

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

1034

raise RuntimeError

1035

except (ValueError, IndexError, RuntimeError), error:

1036

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

1037

return

1038

1039

# Start GnuTLS connection

1040

1026

try:

1041

1027

session.handshake()

1042

1028

except gnutls.errors.GNUTLSError, error:

1046

1032

return

1047

1033

logger.debug(u"Handshake succeeded")

1048

1034

try:

1049

try:

1050

fpr = self.fingerprint(self.peer_certificate

1051

(session))

1052

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

1053

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

1054

return

1055

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

1056

1057

for c in self.server.clients:

1058

if c.fingerprint == fpr:

1059

client = c

1060

break

1061

else:

1062

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

1063

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

1064

return

1065

1066

class ClientProxy(object):

1067

"""Client proxy object. Not for calling methods."""

1068

def __init__(self, client):

1069

self.client = client

1070

def __getattr__(self, name):

1071

if name.startswith("ipc_"):

1072

def tempfunc():

1073

ipc.write("%s %s\n" % (name[4:].upper(),

1074

self.client.name))

1075

return tempfunc

1076

if not hasattr(self.client, name):

1077

raise AttributeError

1078

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

1079

% (name, self.client.fingerprint))

1080

return pickle.load(ipc_return)

1081

clientproxy = ClientProxy(client)

1082

# Have to check if client.enabled, since it is

1083

# possible that the client was disabled since the

1084

# GnuTLS session was established.

1085

if not clientproxy.enabled:

1086

clientproxy.ipc_disabled()

1087

return

1088

1089

clientproxy.ipc_sending()

1090

sent_size = 0

1091

while sent_size < len(client.secret):

1092

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

1093

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

1094

sent, len(client.secret)

1095

- (sent_size + sent))

1096

sent_size += sent

1097

finally:

1098

session.bye()

1035

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

1036

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

1037

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

1038

session.bye()

1039

return

1040

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

1041

1042

for c in self.server.clients:

1043

if c.fingerprint == fpr:

1044

client = c

1045

break

1046

else:

1047

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

1048

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

1049

session.bye()

1050

return

1051

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

1052

# possible that the client timed out while establishing

1053

# the GnuTLS session.

1054

if not client.still_valid():

1055

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

1056

session.bye()

1057

return

1058

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

1059

sent_size = 0

1060

while sent_size < len(client.secret):

1061

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

1062

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

1063

sent, len(client.secret)

1064

- (sent_size + sent))

1065

sent_size += sent

1066

session.bye()

1099

1067

1100

1068

@staticmethod

1101

1069

def peer_certificate(session):

1161

1129

return hex_fpr

1162

1130

1163

1131

1164

class ForkingMixInWithPipes(socketserver.ForkingMixIn, object):

1165

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

1132

class ForkingMixInWithPipe(socketserver.ForkingMixIn, object):

1133

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

1166

1134

def process_request(self, request, client_address):

1167

1135

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

1168

1136

1169

1137

This function creates a new pipe in self.pipe

1170

1138

"""

1171

# Child writes to child_pipe

1172

self.child_pipe = map(os.fdopen, os.pipe(), u"rw", (1, 0))

1173

# Parent writes to parent_pipe

1174

self.parent_pipe = map(os.fdopen, os.pipe(), u"rw", (1, 0))

1175

super(ForkingMixInWithPipes,

1139

self.pipe = os.pipe()

1140

super(ForkingMixInWithPipe,

1176

1141

self).process_request(request, client_address)

1177

# Close unused ends for parent

1178

self.parent_pipe[0].close() # close read end

1179

self.child_pipe[1].close() # close write end

1180

self.add_pipe_fds(self.child_pipe[0], self.parent_pipe[1])

1181

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1142

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

1143

self.add_pipe(self.pipe[0])

1144

def add_pipe(self, pipe):

1182

1145

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

1183

child_pipe_fd.close()

1184

parent_pipe_fd.close()

1185

1186

1187

class IPv6_TCPServer(ForkingMixInWithPipes,

1146

os.close(pipe)

1147

1148

1149

class IPv6_TCPServer(ForkingMixInWithPipe,

1188

1150

socketserver.TCPServer, object):

1189

1151

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

1190

1152

1275

1237

return socketserver.TCPServer.server_activate(self)

1276

1238

def enable(self):

1277

1239

self.enabled = True

1278

def add_pipe_fds(self, child_pipe_fd, parent_pipe_fd):

1240

def add_pipe(self, pipe):

1279

1241

# Call "handle_ipc" for both data and EOF events

1280

gobject.io_add_watch(child_pipe_fd.fileno(),

1281

gobject.IO_IN | gobject.IO_HUP,

1282

functools.partial(self.handle_ipc,

1283

reply = parent_pipe_fd,

1284

sender= child_pipe_fd))

1285

def handle_ipc(self, source, condition, reply=None, sender=None):

1242

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

1243

self.handle_ipc)

1244

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

1286

1245

condition_names = {

1287

1246

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

1288

1247

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

1300

1259

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

1301

1260

conditions_string)

1302

1261

1262

# Turn the pipe file descriptor into a Python file object

1263

if source not in file_objects:

1264

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

1265

1303

1266

# Read a line from the file object

1304

cmdline = sender.readline()

1267

cmdline = file_objects[source].readline()

1305

1268

if not cmdline: # Empty line means end of file

1306

# close the IPC pipes

1307

sender.close()

1308

reply.close()

1269

# close the IPC pipe

1270

file_objects[source].close()

1271

del file_objects[source]

1309

1272

1310

1273

# Stop calling this function

1311

1274

return False

1316

1279

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

1317

1280

1318

1281

if cmd == u"NOTFOUND":

1319

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

1320

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

1321

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

1282

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

1283

args)

1322

1284

if self.use_dbus:

1323

1285

# Emit D-Bus signal

1324

mandos_dbus_service.ClientNotFound(fpr, address)

1325

elif cmd == u"DISABLED":

1286

mandos_dbus_service.ClientNotFound(args)

1287

elif cmd == u"INVALID":

1326

1288

for client in self.clients:

1327

1289

if client.name == args:

1328

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

1290

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

1329

1291

if self.use_dbus:

1330

1292

# Emit D-Bus signal

1331

1293

client.Rejected()

1332

1294

break

1333

1295

else:

1334

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

1296

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

1335

1297

elif cmd == u"SENDING":

1336

1298

for client in self.clients:

1337

1299

if client.name == args:

1344

1306

else:

1345

1307

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

1346

1308

args)

1347

elif cmd == u"GETATTR":

1348

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

1349

for client in self.clients:

1350

if client.fingerprint == fpr:

1351

attr_value = getattr(client, attr_name, None)

1352

logger.debug("IPC reply: %r", attr_value)

1353

pickle.dump(attr_value, reply)

1354

break

1355

else:

1356

logger.error(u"Client %s on address %s requesting "

1357

u"attribute %s not found", fpr, address,

1358

attr_name)

1359

pickle.dump(None, reply)

1360

1309

else:

1361

1310

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

1362

1311

1396

1345

elif suffix == u"w":

1397

1346

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

1398

1347

else:

1399

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

1400

except (ValueError, IndexError), e:

1401

raise ValueError(e.message)

1348

raise ValueError

1349

except (ValueError, IndexError):

1350

raise ValueError

1402

1351

timevalue += delta

1403

1352

return timevalue

1404

1353

1417

1366

def if_nametoindex(interface):

1418

1367

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

1419

1368

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

1420

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

1369

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

1421

1370

ifreq = fcntl.ioctl(s, SIOCGIFINDEX,

1422

1371

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

1423

1372

interface))

1565

1514

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

1566

1515

server_settings[u"port"]),

1567

1516

ClientHandler,

1568

interface=(server_settings[u"interface"]

1569

or None),

1517

interface=server_settings[u"interface"],

1570

1518

use_ipv6=use_ipv6,

1571

1519

gnutls_priority=

1572

1520

server_settings[u"priority"],

1618

1566

bus = dbus.SystemBus()

1619

1567

# End of Avahi example code

1620

1568

if use_dbus:

1621

try:

1622

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

1623

bus, do_not_queue=True)

1624

except dbus.exceptions.NameExistsException, e:

1625

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

1626

use_dbus = False

1627

server_settings[u"use_dbus"] = False

1628

tcp_server.use_dbus = False

1569

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

1629

1570

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

1630

1571

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

1631

1572

servicetype = u"_mandos._tcp",

1657

1598

daemon()

1658

1599

1659

1600

try:

1660

with pidfile:

1601

with closing(pidfile):

1661

1602

pid = os.getpid()

1662

1603

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

1663

1604

del pidfile

1669

1610

pass

1670

1611

del pidfilename

1671

1612

1613

def cleanup():

1614

"Cleanup function; run on exit"

1615

service.cleanup()

1616

1617

while tcp_server.clients:

1618

client = tcp_server.clients.pop()

1619

client.disable_hook = None

1620

client.disable()

1621

1622

atexit.register(cleanup)

1623

1672

1624

if not debug:

1673

1625

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

1674

1626

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

1681

1633

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

1682

1634

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

1683

1635

1684

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

1685

def ClientAdded(self, objpath):

1636

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

1637

def ClientAdded(self, objpath, properties):

1686

1638

"D-Bus signal"

1687

1639

pass

1688

1640

1689

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

1690

def ClientNotFound(self, fingerprint, address):

1641

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

1642

def ClientNotFound(self, fingerprint):

1691

1643

"D-Bus signal"

1692

1644

pass

1693

1645

1719

1671

tcp_server.clients.remove(c)

1720

1672

c.remove_from_connection()

1721

1673

# Don't signal anything except ClientRemoved

1722

c.disable(quiet=True)

1674

c.disable(signal=False)

1723

1675

# Emit D-Bus signal

1724

1676

self.ClientRemoved(object_path, c.name)

1725

1677

return

1726

raise KeyError(object_path)

1678

raise KeyError

1727

1679

1728

1680

del _interface

1729

1681

1730

1682

mandos_dbus_service = MandosDBusService()

1731

1683

1732

def cleanup():

1733

"Cleanup function; run on exit"

1734

service.cleanup()

1735

1736

while tcp_server.clients:

1737

client = tcp_server.clients.pop()

1738

if use_dbus:

1739

client.remove_from_connection()

1740

client.disable_hook = None

1741

# Don't signal anything except ClientRemoved

1742

client.disable(quiet=True)

1743

if use_dbus:

1744

# Emit D-Bus signal

1745

mandos_dbus_service.ClientRemoved(client.dbus_object_path,

1746

client.name)

1747

1748

atexit.register(cleanup)

1749

1750

1684

for client in tcp_server.clients:

1751

1685

if use_dbus:

1752

1686

# Emit D-Bus signal

1753

mandos_dbus_service.ClientAdded(client.dbus_object_path)

1687

mandos_dbus_service.ClientAdded(client.dbus_object_path,

1688

client.GetAll(u""))

1754

1689

client.enable()

1755

1690

1756

1691

tcp_server.enable()

1774

1709

service.activate()

1775

1710

except dbus.exceptions.DBusException, error:

1776

1711

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

1777

cleanup()

1778

1712

sys.exit(1)

1779

1713

# End of Avahi example code

1780

1714

1787

1721

main_loop.run()

1788

1722

except AvahiError, error:

1789

1723

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

1790

cleanup()

1791

1724

sys.exit(1)

1792

1725

except KeyboardInterrupt:

1793

1726

if debug:

1794

1727

print >> sys.stderr

1795

1728

logger.debug(u"Server received KeyboardInterrupt")

1796

1729

logger.debug(u"Server exiting")

1797

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

1798

cleanup()

1799

1730

1800

1731

if __name__ == '__main__':

1801

1732

main()