/mandos/trunk : revision 574

34

from __future__ import (division, absolute_import, print_function,

35

unicode_literals)

36

37

from future_builtins import *

38

39

37

import SocketServer as socketserver

40

38

import socket

41

39

import argparse

379

377

self.server_state_changed)

380

378

self.server_state_changed(self.server.GetState())

381

379

382

383

380

class AvahiServiceToSyslog(AvahiService):

384

381

def rename(self):

385

382

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

390

387

.format(self.name)))

391

388

return ret

392

389

393

394

390

def timedelta_to_milliseconds(td):

395

391

"Convert a datetime.timedelta() to milliseconds"

396

392

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

397

393

+ (td.seconds * 1000)

398

394

+ (td.microseconds // 1000))

399

395

400

401

396

class Client(object):

402

397

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

403

398

442

437

"""

443

438

444

439

runtime_expansions = ("approval_delay", "approval_duration",

445

"created", "enabled", "expires",

446

"fingerprint", "host", "interval",

447

"last_approval_request", "last_checked_ok",

440

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

441

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

448

442

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

449

443

client_defaults = { "timeout": "5m",

450

444

"extended_timeout": "15m",

576

570

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

577

571

# Already enabled

578

572

return

573

self.send_changedstate()

579

574

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

580

575

self.enabled = True

581

576

self.last_enabled = datetime.datetime.utcnow()

582

577

self.init_checker()

583

self.send_changedstate()

584

578

585

579

def disable(self, quiet=True):

586

580

"""Disable this client."""

587

581

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

588

582

return False

589

583

if not quiet:

584

self.send_changedstate()

585

if not quiet:

590

586

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

591

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

587

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

592

588

gobject.source_remove(self.disable_initiator_tag)

593

589

self.disable_initiator_tag = None

594

590

self.expires = None

595

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

591

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

596

592

gobject.source_remove(self.checker_initiator_tag)

597

593

self.checker_initiator_tag = None

598

594

self.stop_checker()

599

595

self.enabled = False

600

if not quiet:

601

self.send_changedstate()

602

596

# Do not run this again if called by a gobject.timeout_add

603

597

return False

604

598

608

602

def init_checker(self):

609

603

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

610

604

# and every interval from then on.

611

if self.checker_initiator_tag is not None:

612

gobject.source_remove(self.checker_initiator_tag)

613

605

self.checker_initiator_tag = (gobject.timeout_add

614

606

(self.interval_milliseconds(),

615

607

self.start_checker))

616

608

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

617

if self.disable_initiator_tag is not None:

618

gobject.source_remove(self.disable_initiator_tag)

619

609

self.disable_initiator_tag = (gobject.timeout_add

620

610

(self.timeout_milliseconds(),

621

611

self.disable))

652

642

timeout = self.timeout

653

643

if self.disable_initiator_tag is not None:

654

644

gobject.source_remove(self.disable_initiator_tag)

655

self.disable_initiator_tag = None

656

645

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

657

646

self.disable_initiator_tag = (gobject.timeout_add

658

647

(timedelta_to_milliseconds

668

657

If a checker already exists, leave it running and do

669

658

nothing."""

670

659

# The reason for not killing a running checker is that if we

671

# did that, and if a checker (for some reason) started running

672

# slowly and taking more than 'interval' time, then the client

673

# would inevitably timeout, since no checker would get a

674

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

660

# did that, then if a checker (for some reason) started

661

# running slowly and taking more than 'interval' time, the

662

# client would inevitably timeout, since no checker would get

663

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

675

664

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

676

665

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

677

666

# should be.

691

680

self.current_checker_command)

692

681

# Start a new checker if needed

693

682

if self.checker is None:

694

# Escape attributes for the shell

695

escaped_attrs = dict(

696

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

697

for attr in

698

self.runtime_expansions)

699

683

try:

700

command = self.checker_command % escaped_attrs

701

except TypeError as error:

702

logger.error('Could not format string "%s"',

703

self.checker_command, exc_info=error)

704

return True # Try again later

684

# In case checker_command has exactly one % operator

685

command = self.checker_command % self.host

686

except TypeError:

687

# Escape attributes for the shell

688

escaped_attrs = dict(

689

(attr,

690

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

691

errors=

692

'replace')))

693

for attr in

694

self.runtime_expansions)

695

696

try:

697

command = self.checker_command % escaped_attrs

698

except TypeError as error:

699

logger.error('Could not format string "%s"',

700

self.checker_command, exc_info=error)

701

return True # Try again later

705

702

self.current_checker_command = command

706

703

try:

707

704

logger.info("Starting checker %r for %s",

713

710

self.checker = subprocess.Popen(command,

714

711

close_fds=True,

715

712

shell=True, cwd="/")

713

self.checker_callback_tag = (gobject.child_watch_add

714

(self.checker.pid,

715

self.checker_callback,

716

data=command))

717

# The checker may have completed before the gobject

718

# watch was added. Check for this.

719

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

720

if pid:

721

gobject.source_remove(self.checker_callback_tag)

722

self.checker_callback(pid, status, command)

716

723

except OSError as error:

717

724

logger.error("Failed to start subprocess",

718

725

exc_info=error)

719

self.checker_callback_tag = (gobject.child_watch_add

720

(self.checker.pid,

721

self.checker_callback,

722

data=command))

723

# The checker may have completed before the gobject

724

# watch was added. Check for this.

725

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

726

if pid:

727

gobject.source_remove(self.checker_callback_tag)

728

self.checker_callback(pid, status, command)

729

726

# Re-run this periodically if run by gobject.timeout_add

730

727

return True

731

728

982

979

tag.appendChild(ann_tag)

983

980

# Add interface annotation tags

984

981

for annotation, value in dict(

985

itertools.chain.from_iterable(

986

annotations().iteritems()

987

for name, annotations in

988

self._get_all_dbus_things("interface")

989

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

990

)).iteritems():

982

itertools.chain(

983

*(annotations().iteritems()

984

for name, annotations in

985

self._get_all_dbus_things("interface")

986

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

987

))).iteritems():

991

988

ann_tag = document.createElement("annotation")

992

989

ann_tag.setAttribute("name", annotation)

993

990

ann_tag.setAttribute("value", value)

1024

1021

variant_level=variant_level)

1025

1022

1026

1023

1027

def alternate_dbus_interfaces(alt_interface_names, deprecate=True):

1028

"""A class decorator; applied to a subclass of

1029

dbus.service.Object, it will add alternate D-Bus attributes with

1030

interface names according to the "alt_interface_names" mapping.

1031

Usage:

1032

1033

@alternate_dbus_names({"org.example.Interface":

1034

"net.example.AlternateInterface"})

1035

class SampleDBusObject(dbus.service.Object):

1036

@dbus.service.method("org.example.Interface")

1037

def SampleDBusMethod():

1038

pass

1039

1040

The above "SampleDBusMethod" on "SampleDBusObject" will be

1041

reachable via two interfaces: "org.example.Interface" and

1042

"net.example.AlternateInterface", the latter of which will have

1043

its D-Bus annotation "org.freedesktop.DBus.Deprecated" set to

1044

"true", unless "deprecate" is passed with a False value.

1045

1046

This works for methods and signals, and also for D-Bus properties

1047

(from DBusObjectWithProperties) and interfaces (from the

1048

dbus_interface_annotations decorator).

1024

class AlternateDBusNamesMetaclass(DBusObjectWithProperties

1025

.__metaclass__):

1026

"""Applied to an empty subclass of a D-Bus object, this metaclass

1027

will add additional D-Bus attributes matching a certain pattern.

1049

1028

"""

1050

def wrapper(cls):

1051

for orig_interface_name, alt_interface_name in (

1052

alt_interface_names.iteritems()):

1053

attr = {}

1054

interface_names = set()

1055

# Go though all attributes of the class

1056

for attrname, attribute in inspect.getmembers(cls):

1029

def __new__(mcs, name, bases, attr):

1030

# Go through all the base classes which could have D-Bus

1031

# methods, signals, or properties in them

1032

old_interface_names = []

1033

for base in (b for b in bases

1034

if issubclass(b, dbus.service.Object)):

1035

# Go though all attributes of the base class

1036

for attrname, attribute in inspect.getmembers(base):

1057

1037

# Ignore non-D-Bus attributes, and D-Bus attributes

1058

1038

# with the wrong interface name

1059

1039

if (not hasattr(attribute, "_dbus_interface")

1060

1040

or not attribute._dbus_interface

1061

.startswith(orig_interface_name)):

1041

.startswith("se.recompile.Mandos")):

1062

1042

continue

1063

1043

# Create an alternate D-Bus interface name based on

1064

1044

# the current name

1065

1045

alt_interface = (attribute._dbus_interface

1066

.replace(orig_interface_name,

1067

alt_interface_name))

1068

interface_names.add(alt_interface)

1046

.replace("se.recompile.Mandos",

1047

"se.bsnet.fukt.Mandos"))

1048

if alt_interface != attribute._dbus_interface:

1049

old_interface_names.append(alt_interface)

1069

1050

# Is this a D-Bus signal?

1070

1051

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

1071

1052

# Extract the original non-method function by

1093

1074

except AttributeError:

1094

1075

pass

1095

1076

# Define a creator of a function to call both the

1096

# original and alternate functions, so both the

1097

# original and alternate signals gets sent when

1098

# the function is called

1077

# old and new functions, so both the old and new

1078

# signals gets sent when the function is called

1099

1079

def fixscope(func1, func2):

1100

1080

"""This function is a scope container to pass

1101

1081

func1 and func2 to the "call_both" function

1108

1088

return call_both

1109

1089

# Create the "call_both" function and add it to

1110

1090

# the class

1111

attr[attrname] = fixscope(attribute, new_function)

1091

attr[attrname] = fixscope(attribute,

1092

new_function)

1112

1093

# Is this a D-Bus method?

1113

1094

elif getattr(attribute, "_dbus_is_method", False):

1114

1095

# Create a new, but exactly alike, function

1170

1151

attribute.func_name,

1171

1152

attribute.func_defaults,

1172

1153

attribute.func_closure)))

1173

if deprecate:

1174

# Deprecate all alternate interfaces

1175

iname="_AlternateDBusNames_interface_annotation{0}"

1176

for interface_name in interface_names:

1177

@dbus_interface_annotations(interface_name)

1178

def func(self):

1179

return { "org.freedesktop.DBus.Deprecated":

1180

"true" }

1181

# Find an unused name

1182

for aname in (iname.format(i)

1183

for i in itertools.count()):

1184

if aname not in attr:

1185

attr[aname] = func

1186

break

1187

if interface_names:

1188

# Replace the class with a new subclass of it with

1189

# methods, signals, etc. as created above.

1190

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

1191

(cls,), attr)

1192

return cls

1193

return wrapper

1194

1195

1196

@alternate_dbus_interfaces({"se.recompile.Mandos":

1197

"se.bsnet.fukt.Mandos"})

1154

# Deprecate all old interfaces

1155

iname="_AlternateDBusNamesMetaclass_interface_annotation{0}"

1156

for old_interface_name in old_interface_names:

1157

@dbus_interface_annotations(old_interface_name)

1158

def func(self):

1159

return { "org.freedesktop.DBus.Deprecated": "true" }

1160

# Find an unused name

1161

for aname in (iname.format(i) for i in itertools.count()):

1162

if aname not in attr:

1163

attr[aname] = func

1164

break

1165

return type.__new__(mcs, name, bases, attr)

1166

1167

1198

1168

class ClientDBus(Client, DBusObjectWithProperties):

1199

1169

"""A Client class using D-Bus

1200

1170

1336

1306

return False

1337

1307

1338

1308

def approve(self, value=True):

1309

self.send_changedstate()

1339

1310

self.approved = value

1340

1311

gobject.timeout_add(timedelta_to_milliseconds

1341

1312

(self.approval_duration),

1342

1313

self._reset_approved)

1343

self.send_changedstate()

1344

1314

1345

1315

## D-Bus methods, signals & properties

1346

1316

_interface = "se.recompile.Mandos.Client"

1530

1500

def Timeout_dbus_property(self, value=None):

1531

1501

if value is None: # get

1532

1502

return dbus.UInt64(self.timeout_milliseconds())

1533

old_timeout = self.timeout

1534

1503

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

1535

# Reschedule disabling

1504

# Reschedule timeout

1536

1505

if self.enabled:

1537

1506

now = datetime.datetime.utcnow()

1538

self.expires += self.timeout - old_timeout

1539

if self.expires <= now:

1507

time_to_die = timedelta_to_milliseconds(

1508

(self.last_checked_ok + self.timeout) - now)

1509

if time_to_die <= 0:

1540

1510

# The timeout has passed

1541

1511

self.disable()

1542

1512

else:

1513

self.expires = (now +

1514

datetime.timedelta(milliseconds =

1515

time_to_die))

1543

1516

if (getattr(self, "disable_initiator_tag", None)

1544

1517

is None):

1545

1518

return

1546

1519

gobject.source_remove(self.disable_initiator_tag)

1547

self.disable_initiator_tag = (

1548

gobject.timeout_add(

1549

timedelta_to_milliseconds(self.expires - now),

1550

self.disable))

1520

self.disable_initiator_tag = (gobject.timeout_add

1521

(time_to_die,

1522

self.disable))

1551

1523

1552

1524

# ExtendedTimeout - property

1553

1525

@dbus_service_property(_interface, signature="t",

1632

1604

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

1633

1605

1634

1606

1607

class ClientDBusTransitional(ClientDBus):

1608

__metaclass__ = AlternateDBusNamesMetaclass

1609

1610

1635

1611

class ClientHandler(socketserver.BaseRequestHandler, object):

1636

1612

"""A class to handle client connections.

1637

1613

1741

1717

#wait until timeout or approved

1742

1718

time = datetime.datetime.now()

1743

1719

client.changedstate.acquire()

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

1720

(client.changedstate.wait

1721

(float(client.timedelta_to_milliseconds(delay)

1722

/ 1000)))

1747

1723

client.changedstate.release()

1748

1724

time2 = datetime.datetime.now()

1749

1725

if (time2 - time) >= delay:

1865

1841

def process_request(self, request, address):

1866

1842

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

1867

1843

proc = multiprocessing.Process(target = self.sub_process_main,

1868

args = (request, address))

1844

args = (request,

1845

address))

1869

1846

proc.start()

1870

1847

return proc

1871

1848

1921

1898

str(self.interface

1922

1899

+ '\0'))

1923

1900

except socket.error as error:

1924

if error.errno == errno.EPERM:

1901

if error[0] == errno.EPERM:

1925

1902

logger.error("No permission to"

1926

1903

" bind to interface %s",

1927

1904

self.interface)

1928

elif error.errno == errno.ENOPROTOOPT:

1905

elif error[0] == errno.ENOPROTOOPT:

1929

1906

logger.error("SO_BINDTODEVICE not available;"

1930

1907

" cannot bind to interface %s",

1931

1908

self.interface)

1932

elif error.errno == errno.ENODEV:

1933

logger.error("Interface %s does not"

1934

" exist, cannot bind",

1935

self.interface)

1936

1909

else:

1937

1910

raise

1938

1911

# Only bind(2) the socket if we really need to.

1997

1970

1998

1971

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

1999

1972

proc = None, client_object=None):

1973

condition_names = {

1974

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

1975

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

1976

# blocking).

1977

gobject.IO_PRI: "PRI", # There is urgent data to read.

1978

gobject.IO_ERR: "ERR", # Error condition.

1979

gobject.IO_HUP: "HUP" # Hung up (the connection has been

1980

# broken, usually for pipes and

1981

# sockets).

1982

}

1983

conditions_string = ' | '.join(name

1984

for cond, name in

1985

condition_names.iteritems()

1986

if cond & condition)

2000

1987

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

2001

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

1988

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

2002

1989

# Wait for other process to exit

2003

1990

proc.join()

2004

1991

return False

2288

2275

os.setgid(gid)

2289

2276

os.setuid(uid)

2290

2277

except OSError as error:

2291

if error.errno != errno.EPERM:

2278

if error[0] != errno.EPERM:

2292

2279

raise error

2293

2280

2294

2281

if debug:

2350

2337

2351

2338

client_class = Client

2352

2339

if use_dbus:

2353

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

2340

client_class = functools.partial(ClientDBusTransitional,

2341

bus = bus)

2354

2342

2355

2343

client_settings = Client.config_parser(client_config)

2356

2344

old_client_settings = {}

2462

2450

# "pidfile" was never created

2463

2451

pass

2464

2452

del pidfilename

2453

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

2465

2454

2466

2455

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

2467

2456

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

2468

2457

2469

2458

if use_dbus:

2470

@alternate_dbus_interfaces({"se.recompile.Mandos":

2471

"se.bsnet.fukt.Mandos"})

2472

2459

class MandosDBusService(DBusObjectWithProperties):

2473

2460

"""A D-Bus proxy object"""

2474

2461

def __init__(self):

2528

2515

2529

2516

del _interface

2530

2517

2531

mandos_dbus_service = MandosDBusService()

2518

class MandosDBusServiceTransitional(MandosDBusService):

2519

__metaclass__ = AlternateDBusNamesMetaclass

2520

mandos_dbus_service = MandosDBusServiceTransitional()

2532

2521

2533

2522

def cleanup():

2534

2523

"Cleanup function; run on exit"

2567

2556

del client_settings[client.name]["secret"]

2568

2557

2569

2558

try:

2570

with (tempfile.NamedTemporaryFile

2571

(mode='wb', suffix=".pickle", prefix='clients-',

2572

dir=os.path.dirname(stored_state_path),

2573

delete=False)) as stored_state:

2559

tempfd, tempname = tempfile.mkstemp(suffix=".pickle",

2560

prefix="clients-",

2561

dir=os.path.dirname

2562

(stored_state_path))

2563

with os.fdopen(tempfd, "wb") as stored_state:

2574

2564

pickle.dump((clients, client_settings), stored_state)

2575

tempname=stored_state.name

2576

2565

os.rename(tempname, stored_state_path)

2577

2566

except (IOError, OSError) as e:

2578

2567

if not debug: