Ящики из веб-почты: администратор создаёт no-reply@, monitor@, support@, задаёт новый пароль, выключает

Регистрация остаётся закрытой. Администраторы — MAIL_ADMINS (по умолчанию первый ящик);
роль не в базе, укравший ящик себя админом не сделает. API /api/admin/mailboxes,
сгенерированный пароль — один раз в ответе, в лог не пишется. Настройки → MAILBOXES
(видно только администратору). Тесты: MailboxAdminControllerTest (5), всего 73.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

backend/src/main/java/com/mailserver/config/MailAdmins.java

@@ -0,0 +1,36 @@
+package com.mailserver.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Who manages mailboxes (Settings → Mailboxes): {@code mailserver.admins} (comma separated), by default the first
+ * mailbox — {@code mailserver.admin.email}, or admin@<first domain>. No role in the database: the list lives in
+ * the configuration, so a stolen mailbox can not make itself an administrator.
+ */
+@Component
+public class MailAdmins {
+
+    private final Set<String> admins;
+
+    public MailAdmins(@Value("${mailserver.admins:}") String admins,
+                      @Value("${mailserver.admin.email:}") String firstMailbox,
+                      MailDomains domains) {
+        String list = !admins.isBlank() ? admins
+                : !firstMailbox.isBlank() ? firstMailbox
+                : "admin@" + domains.domains().iterator().next();
+        this.admins = Arrays.stream(list.split(","))
+                .map(a -> a.trim().toLowerCase(Locale.ROOT))
+                .filter(a -> !a.isEmpty())
+                .collect(Collectors.toUnmodifiableSet());
+    }
+
+    public boolean isAdmin(String email) {
+        return email != null && admins.contains(email.toLowerCase(Locale.ROOT));
+    }
+}

backend/src/main/java/com/mailserver/controller/AuthenticationController.java

@@ -1,5 +1,6 @@
 package com.mailserver.controller;
 
+import com.mailserver.config.MailAdmins;
 import com.mailserver.config.MailDomains;
 import com.mailserver.domain.User;
 import com.mailserver.dto.LoginRequest;
@@ -55,11 +56,13 @@ public class AuthenticationController {
     private final MailDomains domains;
     private final boolean registrationEnabled;
     private final LoginGuard guard;
+    private final MailAdmins admins;
 
     public AuthenticationController(UserService userService, MailService mailService, JwtUtils jwtUtils, MailDomains domains,
                                     @Value("${mailserver.registration.enabled:false}") boolean registrationEnabled,
-                                    LoginGuard guard) {
+                                    LoginGuard guard, MailAdmins admins) {
         this.guard = guard;
+        this.admins = admins;
         this.userService = userService;
         this.mailService = mailService;
         this.jwtUtils = jwtUtils;
@@ -179,7 +182,8 @@ public class AuthenticationController {
     private Mono<ProfileResponse> profile(User user) {
         return mailService.usedBytes(user.getId())
                 .map(used -> new ProfileResponse(user.getEmail(), user.getDisplayName(), used,
-                        user.getQuotaBytes() == null ? 0 : user.getQuotaBytes(), user.getCreatedAt()));
+                        user.getQuotaBytes() == null ? 0 : user.getQuotaBytes(), user.getCreatedAt(),
+                        admins.isAdmin(user.getEmail())));
     }
 
     private Mono<User> user(Mono<Authentication> auth) {

backend/src/main/java/com/mailserver/controller/MailboxAdminController.java

@@ -0,0 +1,165 @@
+package com.mailserver.controller;
+
+import com.mailserver.config.MailAdmins;
+import com.mailserver.config.MailDomains;
+import com.mailserver.domain.User;
+import com.mailserver.service.MailService;
+import com.mailserver.service.UserService;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpStatus;
+import org.springframework.security.core.Authentication;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.security.SecureRandom;
+import java.time.Instant;
+import java.util.Base64;
+import java.util.Comparator;
+import java.util.Locale;
+import java.util.regex.Pattern;
+
+/**
+ * Mailboxes of this server for its administrators ({@link MailAdmins}): list, create (no-reply@, monitor@,
+ * support@ — registration stays closed), new password, switch off. A generated password is returned once, in the
+ * answer — it is not logged.
+ */
+@RestController
+@RequestMapping("/api/admin/mailboxes")
+public class MailboxAdminController {
+
+    private static final Logger log = LoggerFactory.getLogger(MailboxAdminController.class);
+    private static final Pattern LOCAL_PART = Pattern.compile("[a-z0-9](?:[a-z0-9._+-]{0,62}[a-z0-9])?");
+    private static final int MIN_PASSWORD = 10;
+
+    public record MailboxView(Long id, String email, String displayName, boolean active, boolean admin,
+                              long usedBytes, long quotaBytes, Instant createdAt) {
+    }
+
+    /** @param password empty — the server generates one and returns it once */
+    public record CreateRequest(@NotBlank @Size(max = 254) String email, @Size(max = 100) String displayName,
+                                @Size(max = 200) String password) {
+    }
+
+    public record PasswordRequest(@Size(max = 200) String password) {
+    }
+
+    public record ActiveRequest(boolean active) {
+    }
+
+    /** @param password the generated password, or null when the administrator chose it */
+    public record Created(MailboxView mailbox, String password) {
+    }
+
+    private final UserService users;
+    private final MailService mail;
+    private final MailDomains domains;
+    private final MailAdmins admins;
+
+    public MailboxAdminController(UserService users, MailService mail, MailDomains domains, MailAdmins admins) {
+        this.users = users;
+        this.mail = mail;
+        this.domains = domains;
+        this.admins = admins;
+    }
+
+    @GetMapping
+    public Flux<MailboxView> list(Mono<Authentication> auth) {
+        return admin(auth).thenMany(users.all())
+                .concatMap(this::view)
+                .sort(Comparator.comparing(MailboxView::email));
+    }
+
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    public Mono<Created> create(Mono<Authentication> auth, @RequestBody Mono<CreateRequest> body) {
+        return admin(auth).then(body).flatMap(request -> {
+            String email = request.email() == null ? "" : request.email().trim().toLowerCase(Locale.ROOT);
+            int at = email.lastIndexOf('@');
+            if (at <= 0 || !LOCAL_PART.matcher(email.substring(0, at)).matches()) {
+                return Mono.error(bad("Not a mailbox address: " + email));
+            }
+            if (!domains.isLocal(email)) {
+                return Mono.error(bad("Mailboxes can be created only in " + String.join(", ", domains.domains().stream().sorted().toList())));
+            }
+            String chosen = request.password() == null ? "" : request.password();
+            if (!chosen.isEmpty() && chosen.length() < MIN_PASSWORD) {
+                return Mono.error(bad("Password: at least " + MIN_PASSWORD + " characters, or leave it empty to generate one"));
+            }
+            String password = chosen.isEmpty() ? randomPassword() : chosen;
+            return users.register(email, password, request.displayName())
+                    .onErrorMap(IllegalArgumentException.class, e -> new ResponseStatusException(HttpStatus.CONFLICT, "This mailbox already exists"))
+                    .doOnNext(user -> log.info("Mailbox created by administrator: {}", email))
+                    .flatMap(this::view)
+                    .map(view -> new Created(view, chosen.isEmpty() ? password : null));
+        });
+    }
+
+    /** New password: the given one, or a generated one returned once. */
+    @PostMapping("/{id}/password")
+    public Mono<Created> password(Mono<Authentication> auth, @PathVariable Long id, @RequestBody Mono<PasswordRequest> body) {
+        return admin(auth).then(body.defaultIfEmpty(new PasswordRequest(null))).flatMap(request -> {
+            String chosen = request.password() == null ? "" : request.password();
+            if (!chosen.isEmpty() && chosen.length() < MIN_PASSWORD) {
+                return Mono.error(bad("Password: at least " + MIN_PASSWORD + " characters, or leave it empty to generate one"));
+            }
+            String password = chosen.isEmpty() ? randomPassword() : chosen;
+            return mailbox(id)
+                    .flatMap(user -> users.setPassword(user, password))
+                    .doOnNext(user -> log.info("Password of {} set by administrator", user.getEmail()))
+                    .flatMap(this::view)
+                    .map(view -> new Created(view, chosen.isEmpty() ? password : null));
+        });
+    }
+
+    /** Switched off: no login (web, SMTP, IMAP); mail to it is still received. */
+    @PutMapping("/{id}/active")
+    public Mono<MailboxView> active(Mono<Authentication> auth, @PathVariable Long id, @RequestBody Mono<ActiveRequest> body) {
+        return admin(auth).flatMap(me -> body.flatMap(request -> mailbox(id).flatMap(user -> {
+            if (!request.active() && user.getEmail().equalsIgnoreCase(me)) {
+                return Mono.error(bad("You can not switch off your own mailbox"));
+            }
+            log.info("Mailbox {} {} by administrator", user.getEmail(), request.active() ? "switched on" : "switched off");
+            return users.setActive(user, request.active());
+        }))).flatMap(this::view);
+    }
+
+    private Mono<String> admin(Mono<Authentication> auth) {
+        return auth.switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.UNAUTHORIZED)))
+                .map(Authentication::getName)
+                .filter(admins::isAdmin)
+                .switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.FORBIDDEN, "Only for mail administrators")));
+    }
+
+    private Mono<User> mailbox(Long id) {
+        return users.byId(id).switchIfEmpty(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND, "Mailbox not found")));
+    }
+
+    private Mono<MailboxView> view(User user) {
+        return mail.usedBytes(user.getId()).defaultIfEmpty(0L)
+                .map(used -> new MailboxView(user.getId(), user.getEmail(), user.getDisplayName(), user.isActive(),
+                        admins.isAdmin(user.getEmail()), used, user.getQuotaBytes() == null ? 0 : user.getQuotaBytes(),
+                        user.getCreatedAt()));
+    }
+
+    private static ResponseStatusException bad(String message) {
+        return new ResponseStatusException(HttpStatus.BAD_REQUEST, message);
+    }
+
+    static String randomPassword() {
+        byte[] bytes = new byte[18];
+        new SecureRandom().nextBytes(bytes);
+        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
+    }
+}

backend/src/main/java/com/mailserver/dto/ProfileResponse.java

@@ -2,5 +2,7 @@ package com.mailserver.dto;
 
 import java.time.Instant;
 
-public record ProfileResponse(String email, String displayName, long usedBytes, long quotaBytes, Instant createdAt) {
+/** @param admin may manage mailboxes ({@link com.mailserver.config.MailAdmins}) */
+public record ProfileResponse(String email, String displayName, long usedBytes, long quotaBytes, Instant createdAt,
+                              boolean admin) {
 }

backend/src/main/java/com/mailserver/service/UserService.java

@@ -74,6 +74,25 @@ public class UserService {
         return userRepository.save(user).then();
     }
 
+    public Flux<User> all() {
+        return userRepository.findAll();
+    }
+
+    public Mono<User> byId(Long id) {
+        return userRepository.findById(id);
+    }
+
+    /** Administrator sets a new password (Settings → Mailboxes): no current password needed. */
+    public Mono<User> setPassword(User user, String newPassword) {
+        user.setPassword(passwordEncoder.encode(newPassword));
+        return userRepository.save(user);
+    }
+
+    public Mono<User> setActive(User user, boolean active) {
+        user.setActive(active);
+        return userRepository.save(user);
+    }
+
     public Mono<User> updateDisplayName(User user, String displayName) {
         user.setDisplayName(displayName.trim());
         return userRepository.save(user);