PVE/API2/Domains.pm

   1 package PVE::API2::Domains;
   2
   3 use strict;
   4 use warnings;
   5 use PVE::Tools qw(extract_param);
   6 use PVE::Cluster qw (cfs_read_file cfs_write_file);
   7 use PVE::AccessControl;
   8 use PVE::JSONSchema qw(get_standard_option);
   9
  10 use PVE::SafeSyslog;
  11 use PVE::RESTHandler;
  12 use PVE::Auth::Plugin;
  13
  14 my $domainconfigfile = "domains.cfg";
  15
  16 use base qw(PVE::RESTHandler);
  17
  18 __PACKAGE__->register_method ({
  19     name => 'index',
  20     path => '',
  21     method => 'GET',
  22     description => "Authentication domain index.",
  23     permissions => {
  24         description => "Anyone can access that, because we need that list for the login box (before the user is authenticated).",
  25         user => 'world',
  26     },
  27     parameters => {
  28         additionalProperties => 0,
  29         properties => {},
  30     },
  31     returns => {
  32         type => 'array',
  33         items => {
  34             type => "object",
  35             properties => {
  36                 realm => { type => 'string' },
  37                 tfa => {
  38                     description => "Two-factor authentication provider.",
  39                     type => 'string',
  40                     enum => [ 'yubico', 'oath' ],
  41                     optional => 1,
  42                 },
  43                 comment => { type => 'string', optional => 1 },
  44                 comment => { type => 'string', optional => 1 },
  45             },
  46         },
  47         links => [ { rel => 'child', href => "{realm}" } ],
  48     },
  49     code => sub {
  50         my ($param) = @_;
  51
  52         my $res = [];
  53
  54         my $cfg = cfs_read_file($domainconfigfile);
  55         my $ids = $cfg->{ids};
  56
  57         foreach my $realm (keys %$ids) {
  58             my $d = $ids->{$realm};
  59             my $entry = { realm => $realm, type => $d->{type} };
  60             $entry->{comment} = $d->{comment} if $d->{comment};
  61             $entry->{default} = 1 if $d->{default};
  62             if ($d->{tfa} && (my $tfa_cfg = PVE::Auth::Plugin::parse_tfa_config($d->{tfa}))) {
  63                 $entry->{tfa} = $tfa_cfg->{type};
  64             }
  65             push @$res, $entry;
  66         }
  67
  68         return $res;
  69     }});
  70
  71 __PACKAGE__->register_method ({
  72     name => 'create',
  73     protected => 1,
  74     path => '',
  75     method => 'POST',
  76     permissions => {
  77         check => ['perm', '/access/realm', ['Realm.Allocate']],
  78     },
  79     description => "Add an authentication server.",
  80     parameters => PVE::Auth::Plugin->createSchema(),
  81     returns => { type => 'null' },
  82     code => sub {
  83         my ($param) = @_;
  84
  85         PVE::Auth::Plugin::lock_domain_config(
  86             sub {
  87
  88                 my $cfg = cfs_read_file($domainconfigfile);
  89                 my $ids = $cfg->{ids};
  90
  91                 my $realm = extract_param($param, 'realm');
  92                 my $type = $param->{type};
  93
  94                 die "domain '$realm' already exists\n"
  95                     if $ids->{$realm};
  96
  97                 die "unable to use reserved name '$realm'\n"
  98                     if ($realm eq 'pam' || $realm eq 'pve');
  99
 100                 die "unable to create builtin type '$type'\n"
 101                     if ($type eq 'pam' || $type eq 'pve');
 102
 103                 my $plugin = PVE::Auth::Plugin->lookup($type);
 104                 my $config = $plugin->check_config($realm, $param, 1, 1);
 105
 106                 if ($config->{default}) {
 107                     foreach my $r (keys %$ids) {
 108                         delete $ids->{$r}->{default};
 109                     }
 110                 }
 111
 112                 $ids->{$realm} = $config;
 113
 114                 cfs_write_file($domainconfigfile, $cfg);
 115             }, "add auth server failed");
 116
 117         return undef;
 118     }});
 119
 120 __PACKAGE__->register_method ({
 121     name => 'update',
 122     path => '{realm}',
 123     method => 'PUT',
 124     permissions => {
 125         check => ['perm', '/access/realm', ['Realm.Allocate']],
 126     },
 127     description => "Update authentication server settings.",
 128     protected => 1,
 129     parameters => PVE::Auth::Plugin->updateSchema(),
 130     returns => { type => 'null' },
 131     code => sub {
 132         my ($param) = @_;
 133
 134         PVE::Auth::Plugin::lock_domain_config(
 135             sub {
 136
 137                 my $cfg = cfs_read_file($domainconfigfile);
 138                 my $ids = $cfg->{ids};
 139
 140                 my $digest = extract_param($param, 'digest');
 141                 PVE::SectionConfig::assert_if_modified($cfg, $digest);
 142
 143                 my $realm = extract_param($param, 'realm');
 144
 145                 die "domain '$realm' does not exist\n"
 146                     if !$ids->{$realm};
 147
 148                 my $delete_str = extract_param($param, 'delete');
 149                 die "no options specified\n" if !$delete_str && !scalar(keys %$param);
 150
 151                 foreach my $opt (PVE::Tools::split_list($delete_str)) {
 152                     delete $ids->{$realm}->{$opt};
 153                 }
 154
 155                 my $plugin = PVE::Auth::Plugin->lookup($ids->{$realm}->{type});
 156                 my $config = $plugin->check_config($realm, $param, 0, 1);
 157
 158                 if ($config->{default}) {
 159                     foreach my $r (keys %$ids) {
 160                         delete $ids->{$r}->{default};
 161                     }
 162                 }
 163
 164                 foreach my $p (keys %$config) {
 165                     $ids->{$realm}->{$p} = $config->{$p};
 166                 }
 167
 168                 cfs_write_file($domainconfigfile, $cfg);
 169             }, "update auth server failed");
 170
 171         return undef;
 172     }});
 173
 174 # fixme: return format!
 175 __PACKAGE__->register_method ({
 176     name => 'read',
 177     path => '{realm}',
 178     method => 'GET',
 179     description => "Get auth server configuration.",
 180     permissions => {
 181         check => ['perm', '/access/realm', ['Realm.Allocate', 'Sys.Audit'], any => 1],
 182     },
 183     parameters => {
 184         additionalProperties => 0,
 185         properties => {
 186             realm =>  get_standard_option('realm'),
 187         },
 188     },
 189     returns => {},
 190     code => sub {
 191         my ($param) = @_;
 192
 193         my $cfg = cfs_read_file($domainconfigfile);
 194
 195         my $realm = $param->{realm};
 196
 197         my $data = $cfg->{ids}->{$realm};
 198         die "domain '$realm' does not exist\n" if !$data;
 199
 200         $data->{digest} = $cfg->{digest};
 201
 202         return $data;
 203     }});
 204
 205
 206 __PACKAGE__->register_method ({
 207     name => 'delete',
 208     path => '{realm}',
 209     method => 'DELETE',
 210     permissions => {
 211         check => ['perm', '/access/realm', ['Realm.Allocate']],
 212     },
 213     description => "Delete an authentication server.",
 214     protected => 1,
 215     parameters => {
 216         additionalProperties => 0,
 217         properties => {
 218             realm =>  get_standard_option('realm'),
 219         }
 220     },
 221     returns => { type => 'null' },
 222     code => sub {
 223         my ($param) = @_;
 224
 225         PVE::Auth::Plugin::lock_domain_config(
 226             sub {
 227
 228                 my $cfg = cfs_read_file($domainconfigfile);
 229                 my $ids = $cfg->{ids};
 230
 231                 my $realm = $param->{realm};
 232
 233                 die "domain '$realm' does not exist\n" if !$ids->{$realm};
 234
 235                 delete $ids->{$realm};
 236
 237                 cfs_write_file($domainconfigfile, $cfg);
 238             }, "delete auth server failed");
 239
 240         return undef;
 241     }});
 242
 243 1;