b. Auth Service

package boxoffice.auth;

import com.nimbusds.jose.JOSEException;
import com.nimbusds.jose.JOSEObjectType;
import com.nimbusds.jose.JWSAlgorithm;
import com.nimbusds.jose.JWSHeader;
import com.nimbusds.jose.crypto.RSASSASigner;
import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jose.jwk.KeyUse;
import com.nimbusds.jose.jwk.RSAKey;
import com.nimbusds.jose.jwk.gen.RSAKeyGenerator;
import com.nimbusds.jwt.JWTClaimsSet;
import com.nimbusds.jwt.SignedJWT;
import java.time.Duration;
import java.time.Instant;
import java.util.Date;
import java.util.Map;
import java.util.UUID;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * Signs JWTs with a private RSA key (RS256) and publishes the public key as a JWKS.
 * Only auth holds the private key; anyone can verify a token with the public one.
 */
@Component
public class TokenService {

    private final RSAKey key;
    private final String issuer;
    private final String audience;
    private final Duration ttl;

    public TokenService(@Value("${jwt.issuer}") String issuer,
                        @Value("${jwt.audience}") String audience,
                        @Value("${jwt.ttl}") Duration ttl) throws JOSEException {
        // a new key pair at every start: fine for a lab, see the warning in the text
        this.key = new RSAKeyGenerator(2048)
                .keyID(UUID.randomUUID().toString())
                .keyUse(KeyUse.SIGNATURE)
                .algorithm(JWSAlgorithm.RS256)
                .generate();
        this.issuer = issuer;
        this.audience = audience;
        this.ttl = ttl;
    }

    public TokenOut issue(User user) {
        var now = Instant.now();
        var claims = new JWTClaimsSet.Builder()
                .issuer(issuer)
                .audience(audience)
                .subject(user.getId().toString())
                .claim("email", user.getEmail())
                .claim("name", user.getName())
                .claim("scope", user.getRole() == Role.ADMIN ? "user admin" : "user")
                .issueTime(Date.from(now))
                .expirationTime(Date.from(now.plus(ttl)))
                .jwtID(UUID.randomUUID().toString())
                .build();
        var header = new JWSHeader.Builder(JWSAlgorithm.RS256)
                .keyID(key.getKeyID())
                .type(JOSEObjectType.JWT)
                .build();
        try {
            var jwt = new SignedJWT(header, claims);
            jwt.sign(new RSASSASigner(key));
            return new TokenOut(jwt.serialize(), "Bearer", ttl.toSeconds());
        } catch (JOSEException e) {
            throw new IllegalStateException("could not sign the token", e);
        }
    }

    /** The public part only: {"keys":[{"kty":"RSA","kid":"...","n":"...","e":"AQAB",...}]} */
    public Map<String, Object> jwks() {
        return new JWKSet(key.toPublicJWK()).toJSONObject();
    }
}

package boxoffice.auth;

import java.util.UUID;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.http.HttpStatus;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.server.ResponseStatusException;

@Service
public class AuthService {

    private static final Logger log = LoggerFactory.getLogger(AuthService.class);

    private final UserRepository users;
    private final TokenService tokens;
    // cost 10 = 2^10 rounds: deliberately slow (tens of ms) to make password guessing expensive
    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder(10);
    private final String adminEmail;
    private final String adminPassword;

    public AuthService(UserRepository users, TokenService tokens,
                       @Value("${admin.email}") String adminEmail,
                       @Value("${admin.password}") String adminPassword) {
        this.users = users;
        this.tokens = tokens;
        this.adminEmail = adminEmail;
        this.adminPassword = adminPassword;
    }

    @Transactional
    public UserOut register(RegisterIn in) {
        var email = in.email().toLowerCase();
        if (users.existsByEmail(email)) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "e-mail already registered");
        }
        var user = users.save(new User(email, in.name(), encoder.encode(in.password()), Role.USER));
        return UserOut.of(user);
    }

    @Transactional(readOnly = true)
    public TokenOut login(LoginIn in) {
        var user = users.findByEmail(in.email().toLowerCase())
                .filter(u -> encoder.matches(in.password(), u.getPasswordHash()))
                // same answer for "no such user" and "wrong password": do not help attackers
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.UNAUTHORIZED, "invalid credentials"));
        return tokens.issue(user);
    }

    @Transactional(readOnly = true)
    public UserOut find(UUID id) {
        return users.findById(id).map(UserOut::of)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND, "user not found"));
    }

    /** Creates the administrator on the first start (credentials from ADMIN_EMAIL / ADMIN_PASSWORD). */
    @EventListener(ApplicationReadyEvent.class)
    @Transactional
    public void createAdmin() {
        if (!users.existsByEmail(adminEmail)) {
            users.save(new User(adminEmail, "Administrator", encoder.encode(adminPassword), Role.ADMIN));
            log.info("created administrator {}", adminEmail);
        }
    }
}

package boxoffice.auth;

import jakarta.validation.Valid;
import java.util.Map;
import java.util.UUID;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/auth")
public class AuthController {

    private final AuthService service;
    private final TokenService tokens;

    public AuthController(AuthService service, TokenService tokens) {
        this.service = service;
        this.tokens = tokens;
    }

    @PostMapping("/register")
    @ResponseStatus(HttpStatus.CREATED)
    public UserOut register(@Valid @RequestBody RegisterIn in) {
        return service.register(in);
    }

    @PostMapping("/login")
    public TokenOut login(@Valid @RequestBody LoginIn in) {
        return service.login(in);
    }

    /** Protected route: the gateway validated the JWT and tells us who the user is. */
    @GetMapping("/me")
    public UserOut me(@RequestHeader("X-User-Id") UUID userId) {
        return service.find(userId);
    }

    @GetMapping("/.well-known/jwks.json")
    public Map<String, Object> jwks() {
        return tokens.jwks();
    }
}