/mandos/trunk : revision 575

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

88

86

except ImportError:

89

87

SO_BINDTODEVICE = None

90

88

91

version = "1.6.0"

89

version = "1.5.3"

92

90

stored_state_file = "clients.pickle"

93

91

94

92

logger = logging.getLogger()

151

149

def __enter__(self):

152

150

return self

153

151

154

def __exit__(self, exc_type, exc_value, traceback):

152

def __exit__ (self, exc_type, exc_value, traceback):

155

153

self._cleanup()

156

154

return False

157

155

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)

1016

1013

return xmlstring

1017

1014

1018

1015

1019

def datetime_to_dbus(dt, variant_level=0):

1016

def datetime_to_dbus (dt, variant_level=0):

1020

1017

"""Convert a UTC datetime.datetime() to a D-Bus type."""

1021

1018

if dt is None:

1022

1019

return dbus.String("", variant_level = variant_level)

1030

1027

interface names according to the "alt_interface_names" mapping.

1031

1028

Usage:

1032

1029

1033

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

1034

"net.example.AlternateInterface"})

1030

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

1031

"net.example.AlternateInterface"})

1035

1032

class SampleDBusObject(dbus.service.Object):

1036

1033

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

1037

1034

def SampleDBusMethod():

1336

1333

return False

1337

1334

1338

1335

def approve(self, value=True):

1336

self.send_changedstate()

1339

1337

self.approved = value

1340

1338

gobject.timeout_add(timedelta_to_milliseconds

1341

1339

(self.approval_duration),

1342

1340

self._reset_approved)

1343

self.send_changedstate()

1344

1341

1345

1342

## D-Bus methods, signals & properties

1346

1343

_interface = "se.recompile.Mandos.Client"

1530

1527

def Timeout_dbus_property(self, value=None):

1531

1528

if value is None: # get

1532

1529

return dbus.UInt64(self.timeout_milliseconds())

1533

old_timeout = self.timeout

1534

1530

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

1535

# Reschedule disabling

1531

# Reschedule timeout

1536

1532

if self.enabled:

1537

1533

now = datetime.datetime.utcnow()

1538

self.expires += self.timeout - old_timeout

1539

if self.expires <= now:

1534

time_to_die = timedelta_to_milliseconds(

1535

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

1536

if time_to_die <= 0:

1540

1537

# The timeout has passed

1541

1538

self.disable()

1542

1539

else:

1540

self.expires = (now +

1541

datetime.timedelta(milliseconds =

1542

time_to_die))

1543

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

1544

is None):

1545

return

1546

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

1547

self.disable_initiator_tag = (gobject.timeout_add

1548

(time_to_die,

1549

self.disable))

1551

1550

1552

1551

# ExtendedTimeout - property

1553

1552

@dbus_service_property(_interface, signature="t",

1741

1740

#wait until timeout or approved

1742

1741

time = datetime.datetime.now()

1743

1742

client.changedstate.acquire()

1744

client.changedstate.wait(

1745

float(timedelta_to_milliseconds(delay)

1746

/ 1000))

1743

(client.changedstate.wait

1744

(float(client.timedelta_to_milliseconds(delay)

1745

/ 1000)))

1747

1746

client.changedstate.release()

1748

1747

time2 = datetime.datetime.now()

1749

1748

if (time2 - time) >= delay:

1865

1864

def process_request(self, request, address):

1866

1865

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

1867

1866

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

1868

args = (request, address))

1867

args = (request,

1868

address))

1869

proc.start()

1870

return proc

1871

1899

use_ipv6: Boolean; to use IPv6 or not

1900

"""

1901

def __init__(self, server_address, RequestHandlerClass,

1902

interface=None, use_ipv6=True, socketfd=None):

1903

"""If socketfd is set, use that file descriptor instead of

1904

creating a new one with socket.socket().

1905

"""

1902

interface=None, use_ipv6=True):

1906

1903

self.interface = interface

1907

1904

if use_ipv6:

1908

1905

self.address_family = socket.AF_INET6

1909

if socketfd is not None:

1910

# Save the file descriptor

1911

self.socketfd = socketfd

1912

# Save the original socket.socket() function

1913

self.socket_socket = socket.socket

1914

# To implement --socket, we monkey patch socket.socket.

1915

#

1916

# (When socketserver.TCPServer is a new-style class, we

1917

# could make self.socket into a property instead of monkey

1918

# patching socket.socket.)

1919

#

1920

# Create a one-time-only replacement for socket.socket()

1921

@functools.wraps(socket.socket)

1922

def socket_wrapper(*args, **kwargs):

1923

# Restore original function so subsequent calls are

1924

# not affected.

1925

socket.socket = self.socket_socket

1926

del self.socket_socket

1927

# This time only, return a new socket object from the

1928

# saved file descriptor.

1929

return socket.fromfd(self.socketfd, *args, **kwargs)

1930

# Replace socket.socket() function with wrapper

1931

socket.socket = socket_wrapper

1932

# The socketserver.TCPServer.__init__ will call

1933

# socket.socket(), which might be our replacement,

1934

# socket_wrapper(), if socketfd was set.

1935

1906

socketserver.TCPServer.__init__(self, server_address,

1936

1907

RequestHandlerClass)

1937

1938

1908

def server_bind(self):

1939

1909

"""This overrides the normal server_bind() function

1940

1910

to bind to an interface if one was specified, and also NOT to

1948

1918

try:

1949

1919

self.socket.setsockopt(socket.SOL_SOCKET,

1950

1920

SO_BINDTODEVICE,

1951

str(self.interface + '\0'))

1921

str(self.interface

1922

+ '\0'))

1952

1923

except socket.error as error:

1953

if error.errno == errno.EPERM:

1954

logger.error("No permission to bind to"

1955

" interface %s", self.interface)

1956

elif error.errno == errno.ENOPROTOOPT:

1924

if error[0] == errno.EPERM:

1925

logger.error("No permission to"

1926

" bind to interface %s",

1927

self.interface)

1928

elif error[0] == errno.ENOPROTOOPT:

1957

1929

logger.error("SO_BINDTODEVICE not available;"

1958

1930

" cannot bind to interface %s",

1959

1931

self.interface)

1960

elif error.errno == errno.ENODEV:

1961

logger.error("Interface %s does not exist,"

1962

" cannot bind", self.interface)

1963

1932

else:

1964

1933

raise

1965

1934

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

1995

1964

"""

1996

1965

def __init__(self, server_address, RequestHandlerClass,

1997

1966

interface=None, use_ipv6=True, clients=None,

1998

gnutls_priority=None, use_dbus=True, socketfd=None):

1967

gnutls_priority=None, use_dbus=True):

1999

1968

self.enabled = False

2000

1969

self.clients = clients

2001

1970

if self.clients is None:

2005

1974

IPv6_TCPServer.__init__(self, server_address,

2006

1975

RequestHandlerClass,

2007

1976

interface = interface,

2008

use_ipv6 = use_ipv6,

2009

socketfd = socketfd)

1977

use_ipv6 = use_ipv6)

2010

1978

def server_activate(self):

2011

1979

if self.enabled:

2012

1980

return socketserver.TCPServer.server_activate(self)

2025

1993

2026

1994

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

2027

1995

proc = None, client_object=None):

1996

condition_names = {

1997

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

1998

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

1999

# blocking).

2000

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

2001

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

2002

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

2003

# broken, usually for pipes and

2004

# sockets).

2005

}

2006

conditions_string = ' | '.join(name

2007

for cond, name in

2008

condition_names.iteritems()

2009

if cond & condition)

2028

2010

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

2029

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

2011

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

2030

2012

# Wait for other process to exit

2031

2013

proc.join()

2032

2014

return False

2193

2175

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

2194

2176

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

2195

2177

" state")

2196

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

2197

help="Specify a file descriptor to a network"

2198

" socket to use instead of creating one")

2199

2178

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

2200

2179

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

2201

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

2202

help="Run in foreground")

2203

2180

2204

2181

options = parser.parse_args()

2205

2182

2220

2197

"use_ipv6": "True",

2221

2198

"debuglevel": "",

2222

2199

"restore": "True",

2223

"socket": "",

2224

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

2225

"foreground": "False",

2200

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

2226

2201

}

2227

2202

2228

2203

# Parse config file for server-global settings

2233

2208

# Convert the SafeConfigParser object to a dict

2234

2209

server_settings = server_config.defaults()

2235

2210

# Use the appropriate methods on the non-string config options

2236

for option in ("debug", "use_dbus", "use_ipv6", "foreground"):

2211

for option in ("debug", "use_dbus", "use_ipv6"):

2237

2212

server_settings[option] = server_config.getboolean("DEFAULT",

2238

2213

option)

2239

2214

if server_settings["port"]:

2240

2215

server_settings["port"] = server_config.getint("DEFAULT",

2241

2216

"port")

2242

if server_settings["socket"]:

2243

server_settings["socket"] = server_config.getint("DEFAULT",

2244

"socket")

2245

# Later, stdin will, and stdout and stderr might, be dup'ed

2246

# over with an opened os.devnull. But we don't want this to

2247

# happen with a supplied network socket.

2248

if 0 <= server_settings["socket"] <= 2:

2249

server_settings["socket"] = os.dup(server_settings

2250

["socket"])

2251

2217

del server_config

2252

2218

2253

2219

# Override the settings from the config file with command line

2255

2221

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

2256

2222

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

2257

2223

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

2258

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

2224

"statedir"):

2259

2225

value = getattr(options, option)

2260

2226

if value is not None:

2261

2227

server_settings[option] = value

2264

2230

for option in server_settings.keys():

2265

2231

if type(server_settings[option]) is str:

2266

2232

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

2267

# Debug implies foreground

2268

if server_settings["debug"]:

2269

server_settings["foreground"] = True

2270

2233

# Now we have our good server settings in "server_settings"

2271

2234

2272

2235

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

2278

2241

use_ipv6 = server_settings["use_ipv6"]

2279

2242

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

2280

2243

stored_state_file)

2281

foreground = server_settings["foreground"]

2282

2244

2283

2245

if debug:

2284

2246

initlogger(debug, logging.DEBUG)

2313

2275

use_ipv6=use_ipv6,

2314

2276

gnutls_priority=

2315

2277

server_settings["priority"],

2316

use_dbus=use_dbus,

2317

socketfd=(server_settings["socket"]

2318

or None))

2319

if not foreground:

2278

use_dbus=use_dbus)

2279

if not debug:

2320

2280

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

2321

pidfile = None

2322

2281

try:

2323

2282

pidfile = open(pidfilename, "w")

2324

2283

except IOError as e:

2339

2298

os.setgid(gid)

2340

2299

os.setuid(uid)

2341

2300

except OSError as error:

2342

if error.errno != errno.EPERM:

2301

if error[0] != errno.EPERM:

2343

2302

raise error

2344

2303

2345

2304

if debug:

2363

2322

os.close(null)

2364

2323

2365

2324

# Need to fork before connecting to D-Bus

2366

if not foreground:

2325

if not debug:

2367

2326

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

2368

2327

daemon()

2369

2328

2370

# multiprocessing will use threads, so before we use gobject we

2371

# need to inform gobject that threads will be used.

2372

2329

gobject.threads_init()

2373

2330

2374

2331

global main_loop

2502

2459

if not tcp_server.clients:

2503

2460

logger.warning("No clients defined")

2504

2461

2505

if not foreground:

2506

if pidfile is not None:

2507

try:

2508

with pidfile:

2509

pid = os.getpid()

2510

pidfile.write(str(pid) + "\n".encode("utf-8"))

2511

except IOError:

2512

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

2513

pidfilename, pid)

2514

del pidfile

2462

if not debug:

2463

try:

2464

with pidfile:

2465

pid = os.getpid()

2466

pidfile.write(str(pid) + "\n".encode("utf-8"))

2467

del pidfile

2468

except IOError:

2469

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

2470

pidfilename, pid)

2471

except NameError:

2472

# "pidfile" was never created

2473

pass

2515

2474

del pidfilename

2475

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

2516

2476

2517

2477

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

2518

2478

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

2618

2578

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

2619

2579

2620

2580

try:

2621

with (tempfile.NamedTemporaryFile

2622

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

2623

dir=os.path.dirname(stored_state_path),

2624

delete=False)) as stored_state:

2581

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

2582

prefix="clients-",

2583

dir=os.path.dirname

2584

(stored_state_path))

2585

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

2625

2586

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

2626

tempname=stored_state.name

2627

2587

os.rename(tempname, stored_state_path)

2628

2588

except (IOError, OSError) as e:

2629

2589

if not debug: