/mandos/release : revision 237.7.272

1

#!/usr/bin/python

1

#!/usr/bin/python2.7

2

# -*- mode: python; coding: utf-8 -*-

3

#

4

# Mandos server - give out binary blobs to connecting clients.

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

79

import ctypes.util

80

import xml.dom.minidom

81

import inspect

82

import GnuPGInterface

83

82

84

83

try:

85

84

SO_BINDTODEVICE = socket.SO_BINDTODEVICE

89

88

except ImportError:

90

89

SO_BINDTODEVICE = None

91

90

92

version = "1.6.0"

91

version = "1.6.7"

93

92

stored_state_file = "clients.pickle"

94

93

95

94

logger = logging.getLogger()

96

syslogger = (logging.handlers.SysLogHandler

97

(facility = logging.handlers.SysLogHandler.LOG_DAEMON,

98

address = str("/dev/log")))

95

syslogger = None

99

96

100

97

try:

101

98

if_nametoindex = (ctypes.cdll.LoadLibrary

117

114

def initlogger(debug, level=logging.WARNING):

118

115

"""init logger and add loglevel"""

119

116

117

global syslogger

118

syslogger = (logging.handlers.SysLogHandler

119

(facility =

120

logging.handlers.SysLogHandler.LOG_DAEMON,

121

address = str("/dev/log")))

120

122

syslogger.setFormatter(logging.Formatter

121

123

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

122

124

' %(message)s'))

140

142

class PGPEngine(object):

141

143

"""A simple class for OpenPGP symmetric encryption & decryption"""

142

144

def __init__(self):

143

self.gnupg = GnuPGInterface.GnuPG()

144

145

self.tempdir = tempfile.mkdtemp(prefix="mandos-")

145

self.gnupg = GnuPGInterface.GnuPG()

146

self.gnupg.options.meta_interactive = False

147

self.gnupg.options.homedir = self.tempdir

148

self.gnupg.options.extra_args.extend(['--force-mdc',

149

'--quiet',

150

'--no-use-agent'])

146

self.gnupgargs = ['--batch',

147

'--home', self.tempdir,

148

'--force-mdc',

149

'--quiet',

150

'--no-use-agent']

151

152

def __enter__(self):

153

return self

175

def password_encode(self, password):

176

# Passphrase can not be empty and can not contain newlines or

177

# NUL bytes. So we prefix it and hex encode it.

178

return b"mandos" + binascii.hexlify(password)

178

encoded = b"mandos" + binascii.hexlify(password)

179

if len(encoded) > 2048:

180

# GnuPG can't handle long passwords, so encode differently

181

encoded = (b"mandos" + password.replace(b"\\", b"\\\\")

182

.replace(b"\n", b"\\n")

183

.replace(b"\0", b"\\x00"))

184

return encoded

179

185

180

186

def encrypt(self, data, password):

181

self.gnupg.passphrase = self.password_encode(password)

182

with open(os.devnull, "w") as devnull:

183

try:

184

proc = self.gnupg.run(['--symmetric'],

185

create_fhs=['stdin', 'stdout'],

186

attach_fhs={'stderr': devnull})

187

with contextlib.closing(proc.handles['stdin']) as f:

188

f.write(data)

189

with contextlib.closing(proc.handles['stdout']) as f:

190

ciphertext = f.read()

191

proc.wait()

192

except IOError as e:

193

raise PGPError(e)

194

self.gnupg.passphrase = None

187

passphrase = self.password_encode(password)

188

with tempfile.NamedTemporaryFile(dir=self.tempdir

189

) as passfile:

190

passfile.write(passphrase)

191

passfile.flush()

192

proc = subprocess.Popen(['gpg', '--symmetric',

193

'--passphrase-file',

194

passfile.name]

195

+ self.gnupgargs,

196

stdin = subprocess.PIPE,

197

stdout = subprocess.PIPE,

198

stderr = subprocess.PIPE)

199

ciphertext, err = proc.communicate(input = data)

200

if proc.returncode != 0:

201

raise PGPError(err)

195

202

return ciphertext

196

203

197

204

def decrypt(self, data, password):

198

self.gnupg.passphrase = self.password_encode(password)

199

with open(os.devnull, "w") as devnull:

200

try:

201

proc = self.gnupg.run(['--decrypt'],

202

create_fhs=['stdin', 'stdout'],

203

attach_fhs={'stderr': devnull})

204

with contextlib.closing(proc.handles['stdin']) as f:

205

f.write(data)

206

with contextlib.closing(proc.handles['stdout']) as f:

207

decrypted_plaintext = f.read()

208

proc.wait()

209

except IOError as e:

210

raise PGPError(e)

211

self.gnupg.passphrase = None

205

passphrase = self.password_encode(password)

206

with tempfile.NamedTemporaryFile(dir = self.tempdir

207

) as passfile:

208

passfile.write(passphrase)

209

passfile.flush()

210

proc = subprocess.Popen(['gpg', '--decrypt',

211

'--passphrase-file',

212

passfile.name]

213

+ self.gnupgargs,

214

stdin = subprocess.PIPE,

215

stdout = subprocess.PIPE,

216

stderr = subprocess.PIPE)

217

decrypted_plaintext, err = proc.communicate(input

218

= data)

219

if proc.returncode != 0:

220

raise PGPError(err)

212

221

return decrypted_plaintext

213

222

214

223

234

243

Used to optionally bind to the specified interface.

235

244

name: string; Example: 'Mandos'

236

245

type: string; Example: '_mandos._tcp'.

237

See <http://www.dns-sd.org/ServiceTypes.html>

246

See <https://www.iana.org/assignments/service-names-port-numbers>

238

247

port: integer; what port to announce

239

248

TXT: list of strings; TXT record for the service

240

249

domain: string; Domain to publish on, default to .local if empty.

329

338

elif state == avahi.ENTRY_GROUP_FAILURE:

330

339

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

331

340

unicode(error))

332

raise AvahiGroupError("State changed: {0!s}"

341

raise AvahiGroupError("State changed: {!s}"

333

342

.format(error))

334

343

335

344

def cleanup(self):

386

395

"""Add the new name to the syslog messages"""

387

396

ret = AvahiService.rename(self)

388

397

syslogger.setFormatter(logging.Formatter

389

('Mandos ({0}) [%(process)d]:'

398

('Mandos ({}) [%(process)d]:'

390

399

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

391

400

.format(self.name)))

392

401

return ret

393

402

394

403

395

def timedelta_to_milliseconds(td):

396

"Convert a datetime.timedelta() to milliseconds"

397

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

398

+ (td.seconds * 1000)

399

+ (td.microseconds // 1000))

400

401

402

404

class Client(object):

403

405

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

404

406

440

442

runtime_expansions: Allowed attributes for runtime expansion.

441

443

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

442

444

disabled, or None

445

server_settings: The server_settings dict from main()

443

446

"""

444

447

445

448

runtime_expansions = ("approval_delay", "approval_duration",

458

461

"enabled": "True",

459

462

}

460

463

461

def timeout_milliseconds(self):

462

"Return the 'timeout' attribute in milliseconds"

463

return timedelta_to_milliseconds(self.timeout)

464

465

def extended_timeout_milliseconds(self):

466

"Return the 'extended_timeout' attribute in milliseconds"

467

return timedelta_to_milliseconds(self.extended_timeout)

468

469

def interval_milliseconds(self):

470

"Return the 'interval' attribute in milliseconds"

471

return timedelta_to_milliseconds(self.interval)

472

473

def approval_delay_milliseconds(self):

474

return timedelta_to_milliseconds(self.approval_delay)

475

476

464

@staticmethod

477

465

def config_parser(config):

478

466

"""Construct a new dict of client settings of this form:

503

491

"rb") as secfile:

504

492

client["secret"] = secfile.read()

505

493

else:

506

raise TypeError("No secret or secfile for section {0}"

494

raise TypeError("No secret or secfile for section {}"

507

495

.format(section))

508

496

client["timeout"] = string_to_delta(section["timeout"])

509

497

client["extended_timeout"] = string_to_delta(

520

508

521

509

return settings

522

510

523

def __init__(self, settings, name = None):

511

def __init__(self, settings, name = None, server_settings=None):

524

512

self.name = name

513

if server_settings is None:

514

server_settings = {}

515

self.server_settings = server_settings

525

516

# adding all client settings

526

for setting, value in settings.iteritems():

517

for setting, value in settings.items():

527

518

setattr(self, setting, value)

528

519

529

520

if self.enabled:

612

603

if self.checker_initiator_tag is not None:

613

604

gobject.source_remove(self.checker_initiator_tag)

614

605

self.checker_initiator_tag = (gobject.timeout_add

615

(self.interval_milliseconds(),

606

(int(self.interval

607

.total_seconds() * 1000),

616

608

self.start_checker))

617

609

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

618

610

if self.disable_initiator_tag is not None:

619

611

gobject.source_remove(self.disable_initiator_tag)

620

612

self.disable_initiator_tag = (gobject.timeout_add

621

(self.timeout_milliseconds(),

622

self.disable))

613

(int(self.timeout

614

.total_seconds() * 1000),

615

self.disable))

623

616

# Also start a new checker *right now*.

624

617

self.start_checker()

625

618

656

649

self.disable_initiator_tag = None

657

650

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

658

651

self.disable_initiator_tag = (gobject.timeout_add

659

(timedelta_to_milliseconds

660

(timeout), self.disable))

652

(int(timeout.total_seconds()

653

* 1000), self.disable))

661

654

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

662

655

663

656

def need_approval(self):

680

673

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

681

674

try:

682

675

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

683

except (AttributeError, OSError) as error:

684

if (isinstance(error, OSError)

685

and error.errno != errno.ECHILD):

686

raise error

676

except AttributeError:

677

pass

678

except OSError as error:

679

if error.errno != errno.ECHILD:

680

raise

687

681

else:

688

682

if pid:

689

683

logger.warning("Checker was a zombie")

693

687

# Start a new checker if needed

694

688

if self.checker is None:

695

689

# Escape attributes for the shell

696

escaped_attrs = dict(

697

(attr, re.escape(unicode(getattr(self, attr))))

698

for attr in

699

self.runtime_expansions)

690

escaped_attrs = { attr:

691

re.escape(unicode(getattr(self,

692

attr)))

693

for attr in self.runtime_expansions }

700

694

try:

701

695

command = self.checker_command % escaped_attrs

702

696

except TypeError as error:

711

705

# in normal mode, that is already done by daemon(),

712

706

# and in debug mode we don't want to. (Stdin is

713

707

# always replaced by /dev/null.)

708

# The exception is when not debugging but nevertheless

709

# running in the foreground; use the previously

710

# created wnull.

711

popen_args = {}

712

if (not self.server_settings["debug"]

713

and self.server_settings["foreground"]):

714

popen_args.update({"stdout": wnull,

715

"stderr": wnull })

714

716

self.checker = subprocess.Popen(command,

715

717

close_fds=True,

716

shell=True, cwd="/")

718

shell=True, cwd="/",

719

**popen_args)

717

720

except OSError as error:

718

721

logger.error("Failed to start subprocess",

719

722

exc_info=error)

723

return True

720

724

self.checker_callback_tag = (gobject.child_watch_add

721

725

(self.checker.pid,

722

726

self.checker_callback,

723

727

data=command))

724

728

# The checker may have completed before the gobject

725

729

# watch was added. Check for this.

726

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

730

try:

731

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

732

except OSError as error:

733

if error.errno == errno.ECHILD:

734

# This should never happen

735

logger.error("Child process vanished",

736

exc_info=error)

737

return True

738

raise

727

739

if pid:

728

740

gobject.source_remove(self.checker_callback_tag)

729

741

self.checker_callback(pid, status, command)

765

777

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

766

778

if byte_arrays and signature != "ay":

767

779

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

768

" signature {0!r}".format(signature))

780

" signature {!r}".format(signature))

769

781

def decorator(func):

770

782

func._dbus_is_property = True

771

783

func._dbus_interface = dbus_interface

850

862

If called like _is_dbus_thing("method") it returns a function

851

863

suitable for use as predicate to inspect.getmembers().

852

864

"""

853

return lambda obj: getattr(obj, "_dbus_is_{0}".format(thing),

865

return lambda obj: getattr(obj, "_dbus_is_{}".format(thing),

854

866

False)

855

867

856

868

def _get_all_dbus_things(self, thing):

905

917

# The byte_arrays option is not supported yet on

906

918

# signatures other than "ay".

907

919

if prop._dbus_signature != "ay":

908

raise ValueError

920

raise ValueError("Byte arrays not supported for non-"

921

"'ay' signature {!r}"

922

.format(prop._dbus_signature))

909

923

value = dbus.ByteArray(b''.join(chr(byte)

910

924

for byte in value))

911

925

prop(value)

975

989

(prop,

976

990

"_dbus_annotations",

977

991

{}))

978

for name, value in annots.iteritems():

992

for name, value in annots.items():

979

993

ann_tag = document.createElement(

980

994

"annotation")

981

995

ann_tag.setAttribute("name", name)

984

998

# Add interface annotation tags

985

999

for annotation, value in dict(

986

1000

itertools.chain.from_iterable(

987

annotations().iteritems()

1001

annotations().items()

988

1002

for name, annotations in

989

1003

self._get_all_dbus_things("interface")

990

1004

if name == if_tag.getAttribute("name")

991

)).iteritems():

1005

)).items():

992

1006

ann_tag = document.createElement("annotation")

993

1007

ann_tag.setAttribute("name", annotation)

994

1008

ann_tag.setAttribute("value", value)

1050

1064

"""

1051

1065

def wrapper(cls):

1052

1066

for orig_interface_name, alt_interface_name in (

1053

alt_interface_names.iteritems()):

1067

alt_interface_names.items()):

1054

1068

attr = {}

1055

1069

interface_names = set()

1056

1070

# Go though all attributes of the class

1069

1083

interface_names.add(alt_interface)

1070

1084

# Is this a D-Bus signal?

1071

1085

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

1072

# Extract the original non-method function by

1073

# black magic

1086

# Extract the original non-method undecorated

1087

# function by black magic

1074

1088

nonmethod_func = (dict(

1075

1089

zip(attribute.func_code.co_freevars,

1076

1090

attribute.__closure__))["func"]

1173

1187

attribute.func_closure)))

1174

1188

if deprecate:

1175

1189

# Deprecate all alternate interfaces

1176

iname="_AlternateDBusNames_interface_annotation{0}"

1190

iname="_AlternateDBusNames_interface_annotation{}"

1177

1191

for interface_name in interface_names:

1178

1192

@dbus_interface_annotations(interface_name)

1179

1193

def func(self):

1188

1202

if interface_names:

1189

1203

# Replace the class with a new subclass of it with

1190

1204

# methods, signals, etc. as created above.

1191

cls = type(b"{0}Alternate".format(cls.__name__),

1205

cls = type(b"{}Alternate".format(cls.__name__),

1192

1206

(cls,), attr)

1193

1207

return cls

1194

1208

return wrapper

1235

1249

to the D-Bus. Default: no transform

1236

1250

variant_level: D-Bus variant level. Default: 1

1237

1251

"""

1238

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

1252

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

1239

1253

def setter(self, value):

1240

1254

if hasattr(self, "dbus_object_path"):

1241

1255

if (not hasattr(self, attrname) or

1271

1285

approval_delay = notifychangeproperty(dbus.UInt64,

1272

1286

"ApprovalDelay",

1273

1287

type_func =

1274

timedelta_to_milliseconds)

1288

lambda td: td.total_seconds()

1289

* 1000)

1275

1290

approval_duration = notifychangeproperty(

1276

1291

dbus.UInt64, "ApprovalDuration",

1277

type_func = timedelta_to_milliseconds)

1292

type_func = lambda td: td.total_seconds() * 1000)

1278

1293

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

1279

1294

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

1280

type_func =

1281

timedelta_to_milliseconds)

1295

type_func = lambda td:

1296

td.total_seconds() * 1000)

1282

1297

extended_timeout = notifychangeproperty(

1283

1298

dbus.UInt64, "ExtendedTimeout",

1284

type_func = timedelta_to_milliseconds)

1299

type_func = lambda td: td.total_seconds() * 1000)

1285

1300

interval = notifychangeproperty(dbus.UInt64,

1286

1301

"Interval",

1287

1302

type_func =

1288

timedelta_to_milliseconds)

1303

lambda td: td.total_seconds()

1304

* 1000)

1289

1305

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

1290

1306

1291

1307

del notifychangeproperty

1319

1335

*args, **kwargs)

1320

1336

1321

1337

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

1322

old_checker = self.checker

1323

if self.checker is not None:

1324

old_checker_pid = self.checker.pid

1325

else:

1326

old_checker_pid = None

1338

old_checker_pid = getattr(self.checker, "pid", None)

1327

1339

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

1328

1340

# Only if new checker process was started

1329

1341

if (self.checker is not None

1338

1350

1339

1351

def approve(self, value=True):

1340

1352

self.approved = value

1341

gobject.timeout_add(timedelta_to_milliseconds

1342

(self.approval_duration),

1343

self._reset_approved)

1353

gobject.timeout_add(int(self.approval_duration.total_seconds()

1354

* 1000), self._reset_approved)

1344

1355

self.send_changedstate()

1345

1356

1346

1357

## D-Bus methods, signals & properties

1449

1460

access="readwrite")

1450

1461

def ApprovalDelay_dbus_property(self, value=None):

1451

1462

if value is None: # get

1452

return dbus.UInt64(self.approval_delay_milliseconds())

1463

return dbus.UInt64(self.approval_delay.total_seconds()

1464

* 1000)

1453

1465

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

1454

1466

1455

1467

# ApprovalDuration - property

1457

1469

access="readwrite")

1458

1470

def ApprovalDuration_dbus_property(self, value=None):

1459

1471

if value is None: # get

1460

return dbus.UInt64(timedelta_to_milliseconds(

1461

self.approval_duration))

1472

return dbus.UInt64(self.approval_duration.total_seconds()

1473

* 1000)

1462

1474

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

1463

1475

1464

1476

# Name - property

1530

1542

access="readwrite")

1531

1543

def Timeout_dbus_property(self, value=None):

1532

1544

if value is None: # get

1533

return dbus.UInt64(self.timeout_milliseconds())

1545

return dbus.UInt64(self.timeout.total_seconds() * 1000)

1534

1546

old_timeout = self.timeout

1535

1547

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

1536

1548

# Reschedule disabling

1547

1559

gobject.source_remove(self.disable_initiator_tag)

1548

1560

self.disable_initiator_tag = (

1549

1561

gobject.timeout_add(

1550

timedelta_to_milliseconds(self.expires - now),

1551

self.disable))

1562

int((self.expires - now).total_seconds()

1563

* 1000), self.disable))

1552

1564

1553

1565

# ExtendedTimeout - property

1554

1566

@dbus_service_property(_interface, signature="t",

1555

1567

access="readwrite")

1556

1568

def ExtendedTimeout_dbus_property(self, value=None):

1557

1569

if value is None: # get

1558

return dbus.UInt64(self.extended_timeout_milliseconds())

1570

return dbus.UInt64(self.extended_timeout.total_seconds()

1571

* 1000)

1559

1572

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

1560

1573

1561

1574

# Interval - property

1563

1576

access="readwrite")

1564

1577

def Interval_dbus_property(self, value=None):

1565

1578

if value is None: # get

1566

return dbus.UInt64(self.interval_milliseconds())

1579

return dbus.UInt64(self.interval.total_seconds() * 1000)

1567

1580

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

1568

1581

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

1569

1582

return

1674

1687

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

1675

1688

try:

1676

1689

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

1677

raise RuntimeError

1690

raise RuntimeError(line)

1678

1691

except (ValueError, IndexError, RuntimeError) as error:

1679

1692

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

1680

1693

return

1729

1742

if self.server.use_dbus:

1730

1743

# Emit D-Bus signal

1731

1744

client.NeedApproval(

1732

client.approval_delay_milliseconds(),

1733

client.approved_by_default)

1745

client.approval_delay.total_seconds()

1746

* 1000, client.approved_by_default)

1734

1747

else:

1735

1748

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

1736

1749

client.name)

1742

1755

#wait until timeout or approved

1743

1756

time = datetime.datetime.now()

1744

1757

client.changedstate.acquire()

1745

client.changedstate.wait(

1746

float(timedelta_to_milliseconds(delay)

1747

/ 1000))

1758

client.changedstate.wait(delay.total_seconds())

1748

1759

client.changedstate.release()

1749

1760

time2 = datetime.datetime.now()

1750

1761

if (time2 - time) >= delay:

1887

1898

1888

1899

def add_pipe(self, parent_pipe, proc):

1889

1900

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

1890

raise NotImplementedError

1901

raise NotImplementedError()

1891

1902

1892

1903

1893

1904

class IPv6_TCPServer(MultiprocessingMixInWithPipe,

1969

1980

if self.address_family == socket.AF_INET6:

1970

1981

any_address = "::" # in6addr_any

1971

1982

else:

1972

any_address = socket.INADDR_ANY

1983

any_address = "0.0.0.0" # INADDR_ANY

1973

1984

self.server_address = (any_address,

1974

1985

self.server_address[1])

1975

1986

elif not self.server_address[1]:

2158

2169

token_duration = Token(re.compile(r"P"), None,

2159

2170

frozenset((token_year, token_month,

2160

2171

token_day, token_time,

2161

token_week))),

2172

token_week)))

2162

2173

# Define starting values

2163

2174

value = datetime.timedelta() # Value so far

2164

2175

found_token = None

2165

followers = frozenset(token_duration,) # Following valid tokens

2176

followers = frozenset((token_duration,)) # Following valid tokens

2166

2177

s = duration # String left to parse

2167

2178

# Loop until end token is found

2168

2179

while found_token is not token_end:

2228

2239

elif suffix == "w":

2229

2240

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

2230

2241

else:

2231

raise ValueError("Unknown suffix {0!r}"

2242

raise ValueError("Unknown suffix {!r}"

2232

2243

.format(suffix))

2233

except (ValueError, IndexError) as e:

2244

except IndexError as e:

2234

2245

raise ValueError(*(e.args))

2235

2246

timevalue += delta

2236

2247

return timevalue

2251

2262

# Close all standard open file descriptors

2252

2263

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

2253

2264

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

2254

raise OSError(errno.ENODEV,

2255

"{0} not a character device"

2265

raise OSError(errno.ENODEV, "{} not a character device"

2256

2266

.format(os.devnull))

2257

2267

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

2258

2268

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

2268

2278

2269

2279

parser = argparse.ArgumentParser()

2270

2280

parser.add_argument("-v", "--version", action="version",

2271

version = "%(prog)s {0}".format(version),

2281

version = "%(prog)s {}".format(version),

2272

2282

help="show version number and exit")

2273

2283

parser.add_argument("-i", "--interface", metavar="IF",

2274

2284

help="Bind to interface IF")

2280

2290

help="Run self-test")

2281

2291

parser.add_argument("--debug", action="store_true",

2282

2292

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

2283

" to terminal")

2293

" to terminal", default=None)

2284

2294

parser.add_argument("--debuglevel", metavar="LEVEL",

2285

2295

help="Debug level for stdout output")

2286

2296

parser.add_argument("--priority", help="GnuTLS"

2293

2303

" files")

2294

2304

parser.add_argument("--no-dbus", action="store_false",

2295

2305

dest="use_dbus", help="Do not provide D-Bus"

2296

" system bus interface")

2306

" system bus interface", default=None)

2297

2307

parser.add_argument("--no-ipv6", action="store_false",

2298

dest="use_ipv6", help="Do not use IPv6")

2308

dest="use_ipv6", help="Do not use IPv6",

2309

default=None)

2299

2310

parser.add_argument("--no-restore", action="store_false",

2300

2311

dest="restore", help="Do not restore stored"

2301

" state")

2312

" state", default=None)

2302

2313

parser.add_argument("--socket", type=int,

2303

2314

help="Specify a file descriptor to a network"

2304

2315

" socket to use instead of creating one")

2305

2316

parser.add_argument("--statedir", metavar="DIR",

2306

2317

help="Directory to save/restore state in")

2307

2318

parser.add_argument("--foreground", action="store_true",

2308

help="Run in foreground")

2319

help="Run in foreground", default=None)

2320

parser.add_argument("--no-zeroconf", action="store_false",

2321

dest="zeroconf", help="Do not use Zeroconf",

2322

default=None)

2309

2323

2310

2324

options = parser.parse_args()

2311

2325

2312

2326

if options.check:

2313

2327

import doctest

2314

doctest.testmod()

2315

sys.exit()

2328

fail_count, test_count = doctest.testmod()

2329

sys.exit(os.EX_OK if fail_count == 0 else 1)

2316

2330

2317

2331

# Default values for config file for server-global settings

2318

2332

server_defaults = { "interface": "",

2320

2334

"port": "",

2321

2335

"debug": "False",

2322

2336

"priority":

2323

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP",

2337

"SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:+SIGN-RSA-SHA224:+SIGN-RSA-RMD160",

2324

2338

"servicename": "Mandos",

2325

2339

"use_dbus": "True",

2326

2340

"use_ipv6": "True",

2329

2343

"socket": "",

2330

2344

"statedir": "/var/lib/mandos",

2331

2345

"foreground": "False",

2346

"zeroconf": "True",

2332

2347

}

2333

2348

2334

2349

# Parse config file for server-global settings

2361

2376

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

2362

2377

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

2363

2378

"use_dbus", "use_ipv6", "debuglevel", "restore",

2364

"statedir", "socket", "foreground"):

2379

"statedir", "socket", "foreground", "zeroconf"):

2365

2380

value = getattr(options, option)

2366

2381

if value is not None:

2367

2382

server_settings[option] = value

2370

2385

for option in server_settings.keys():

2371

2386

if type(server_settings[option]) is str:

2372

2387

server_settings[option] = unicode(server_settings[option])

2388

# Force all boolean options to be boolean

2389

for option in ("debug", "use_dbus", "use_ipv6", "restore",

2390

"foreground", "zeroconf"):

2391

server_settings[option] = bool(server_settings[option])

2373

2392

# Debug implies foreground

2374

2393

if server_settings["debug"]:

2375

2394

server_settings["foreground"] = True

2377

2396

2378

2397

##################################################################

2379

2398

2399

if (not server_settings["zeroconf"] and

2400

not (server_settings["port"]

2401

or server_settings["socket"] != "")):

2402

parser.error("Needs port or socket to work without"

2403

" Zeroconf")

2404

2380

2405

# For convenience

2381

2406

debug = server_settings["debug"]

2382

2407

debuglevel = server_settings["debuglevel"]

2385

2410

stored_state_path = os.path.join(server_settings["statedir"],

2386

2411

stored_state_file)

2387

2412

foreground = server_settings["foreground"]

2413

zeroconf = server_settings["zeroconf"]

2388

2414

2389

2415

if debug:

2390

2416

initlogger(debug, logging.DEBUG)

2397

2423

2398

2424

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

2399

2425

syslogger.setFormatter(logging.Formatter

2400

('Mandos ({0}) [%(process)d]:'

2426

('Mandos ({}) [%(process)d]:'

2401

2427

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

2402

2428

.format(server_settings

2403

2429

["servicename"])))

2411

2437

global mandos_dbus_service

2412

2438

mandos_dbus_service = None

2413

2439

2440

socketfd = None

2441

if server_settings["socket"] != "":

2442

socketfd = server_settings["socket"]

2414

2443

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

2415

2444

server_settings["port"]),

2416

2445

ClientHandler,

2420

2449

gnutls_priority=

2421

2450

server_settings["priority"],

2422

2451

use_dbus=use_dbus,

2423

socketfd=(server_settings["socket"]

2424

or None))

2452

socketfd=socketfd)

2425

2453

if not foreground:

2426

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

2454

pidfilename = "/run/mandos.pid"

2455

if not os.path.isdir("/run/."):

2456

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

2427

2457

pidfile = None

2428

2458

try:

2429

2459

pidfile = open(pidfilename, "w")

2446

2476

os.setuid(uid)

2447

2477

except OSError as error:

2448

2478

if error.errno != errno.EPERM:

2449

raise error

2479

raise

2450

2480

2451

2481

if debug:

2452

2482

# Enable all possible GnuTLS debugging

2495

2525

use_dbus = False

2496

2526

server_settings["use_dbus"] = False

2497

2527

tcp_server.use_dbus = False

2498

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2499

service = AvahiServiceToSyslog(name =

2500

server_settings["servicename"],

2501

servicetype = "_mandos._tcp",

2502

protocol = protocol, bus = bus)

2503

if server_settings["interface"]:

2504

service.interface = (if_nametoindex

2505

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

2528

if zeroconf:

2529

protocol = avahi.PROTO_INET6 if use_ipv6 else avahi.PROTO_INET

2530

service = AvahiServiceToSyslog(name =

2531

server_settings["servicename"],

2532

servicetype = "_mandos._tcp",

2533

protocol = protocol, bus = bus)

2534

if server_settings["interface"]:

2535

service.interface = (if_nametoindex

2536

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

2506

2537

2507

2538

global multiprocessing_manager

2508

2539

multiprocessing_manager = multiprocessing.Manager()

2515

2546

old_client_settings = {}

2516

2547

clients_data = {}

2517

2548

2549

# This is used to redirect stdout and stderr for checker processes

2550

global wnull

2551

wnull = open(os.devnull, "w") # A writable /dev/null

2552

# Only used if server is running in foreground but not in debug

2553

# mode

2554

if debug or not foreground:

2555

wnull.close()

2556

2518

2557

# Get client data and settings from last running state.

2519

2558

if server_settings["restore"]:

2520

2559

try:

2524

2563

os.remove(stored_state_path)

2525

2564

except IOError as e:

2526

2565

if e.errno == errno.ENOENT:

2527

logger.warning("Could not load persistent state: {0}"

2566

logger.warning("Could not load persistent state: {}"

2528

2567

.format(os.strerror(e.errno)))

2529

2568

else:

2530

2569

logger.critical("Could not load persistent state:",

2535

2574

"EOFError:", exc_info=e)

2536

2575

2537

2576

with PGPEngine() as pgp:

2538

for client_name, client in clients_data.iteritems():

2577

for client_name, client in clients_data.items():

2578

# Skip removed clients

2579

if client_name not in client_settings:

2580

continue

2581

2539

2582

# Decide which value to use after restoring saved state.

2540

2583

# We have three different values: Old config file,

2541

2584

# new config file, and saved state.

2562

2605

if datetime.datetime.utcnow() >= client["expires"]:

2563

2606

if not client["last_checked_ok"]:

2564

2607

logger.warning(

2565

"disabling client {0} - Client never "

2608

"disabling client {} - Client never "

2566

2609

"performed a successful checker"

2567

2610

.format(client_name))

2568

2611

client["enabled"] = False

2569

2612

elif client["last_checker_status"] != 0:

2570

2613

logger.warning(

2571

"disabling client {0} - Client "

2572

"last checker failed with error code {1}"

2614

"disabling client {} - Client last"

2615

" checker failed with error code {}"

2573

2616

.format(client_name,

2574

2617

client["last_checker_status"]))

2575

2618

client["enabled"] = False

2578

2621

.utcnow()

2579

2622

+ client["timeout"])

2580

2623

logger.debug("Last checker succeeded,"

2581

" keeping {0} enabled"

2624

" keeping {} enabled"

2582

2625

.format(client_name))

2583

2626

try:

2584

2627

client["secret"] = (

2587

2630

["secret"]))

2588

2631

except PGPError:

2589

2632

# If decryption fails, we use secret from new settings

2590

logger.debug("Failed to decrypt {0} old secret"

2633

logger.debug("Failed to decrypt {} old secret"

2591

2634

.format(client_name))

2592

2635

client["secret"] = (

2593

2636

client_settings[client_name]["secret"])

2601

2644

clients_data[client_name] = client_settings[client_name]

2602

2645

2603

2646

# Create all client objects

2604

for client_name, client in clients_data.iteritems():

2647

for client_name, client in clients_data.items():

2605

2648

tcp_server.clients[client_name] = client_class(

2606

name = client_name, settings = client)

2649

name = client_name, settings = client,

2650

server_settings = server_settings)

2607

2651

2608

2652

if not tcp_server.clients:

2609

2653

logger.warning("No clients defined")

2689

2733

2690

2734

def cleanup():

2691

2735

"Cleanup function; run on exit"

2692

service.cleanup()

2736

if zeroconf:

2737

service.cleanup()

2693

2738

2694

2739

multiprocessing.active_children()

2740

wnull.close()

2695

2741

if not (tcp_server.clients or client_settings):

2696

2742

return

2697

2743

2708

2754

2709

2755

# A list of attributes that can not be pickled

2710

2756

# + secret.

2711

exclude = set(("bus", "changedstate", "secret",

2712

"checker"))

2757

exclude = { "bus", "changedstate", "secret",

2758

"checker", "server_settings" }

2713

2759

for name, typ in (inspect.getmembers

2714

2760

(dbus.service.Object)):

2715

2761

exclude.add(name)

2738

2784

except NameError:

2739

2785

pass

2740

2786

if e.errno in (errno.ENOENT, errno.EACCES, errno.EEXIST):

2741

logger.warning("Could not save persistent state: {0}"

2787

logger.warning("Could not save persistent state: {}"

2742

2788

.format(os.strerror(e.errno)))

2743

2789

else:

2744

2790

logger.warning("Could not save persistent state:",

2745

2791

exc_info=e)

2746

raise e

2792

raise

2747

2793

2748

2794

# Delete all clients, and settings from config

2749

2795

while tcp_server.clients:

2773

2819

tcp_server.server_activate()

2774

2820

2775

2821

# Find out what port we got

2776

service.port = tcp_server.socket.getsockname()[1]

2822

if zeroconf:

2823

service.port = tcp_server.socket.getsockname()[1]

2777

2824

if use_ipv6:

2778

2825

logger.info("Now listening on address %r, port %d,"

2779

2826

" flowinfo %d, scope_id %d",

2785

2832

#service.interface = tcp_server.socket.getsockname()[3]

2786

2833

2787

2834

try:

2788

# From the Avahi example code

2789

try:

2790

service.activate()

2791

except dbus.exceptions.DBusException as error:

2792

logger.critical("D-Bus Exception", exc_info=error)

2793

cleanup()

2794

sys.exit(1)

2795

# End of Avahi example code

2835

if zeroconf:

2836

# From the Avahi example code

2837

try:

2838

service.activate()

2839

except dbus.exceptions.DBusException as error:

2840

logger.critical("D-Bus Exception", exc_info=error)

2841

cleanup()

2842

sys.exit(1)

2843

# End of Avahi example code

2796

2844

2797

2845

gobject.io_add_watch(tcp_server.fileno(), gobject.IO_IN,

2798

2846

lambda *args, **kwargs: