diff --git a/backend/src/main/java/run/webup/platform/AuthController.java b/backend/src/main/java/run/webup/platform/AuthController.java index be9675f..0d0490e 100644 --- a/backend/src/main/java/run/webup/platform/AuthController.java +++ b/backend/src/main/java/run/webup/platform/AuthController.java @@ -38,7 +38,7 @@ public class AuthController { @NotBlank @Size(max = 10) String captchaCode) {} public static String ip(HttpServletRequest req) { - return req.getRemoteAddr(); + return ClientIp.of(req); } public static String ua(HttpServletRequest req) { @@ -52,8 +52,13 @@ public class AuthController { } private void check(String email, String id, String code, HttpServletRequest r) { - store.limit("auth-ip:" + ip(r), 20, 60); + String address = ip(r); + // Per-address bucket: a single client cannot exhaust the shared allowance for everyone. + store.limit("auth-ip:" + address, 20, 60); store.limit("auth-email:" + SecurityConfig.hash(email.toLowerCase(Locale.ROOT)), 10, 300); + // Global ceiling across all addresses, raised well above the per-address limit so ordinary + // traffic is never affected while total login throughput stays bounded. + store.limit("auth-global", 600, 60); captcha.verify(id, code); } diff --git a/backend/src/main/java/run/webup/platform/ClientIp.java b/backend/src/main/java/run/webup/platform/ClientIp.java new file mode 100644 index 0000000..9d2e4e2 --- /dev/null +++ b/backend/src/main/java/run/webup/platform/ClientIp.java @@ -0,0 +1,114 @@ +package run.webup.platform; + +import jakarta.servlet.http.HttpServletRequest; +import java.net.InetAddress; +import java.util.List; + +/** + * Resolves the real client address behind the bundled reverse proxy. + * + *

The control plane is normally reached through the frontend nginx container. Because that proxy + * overwrites the forwarded headers, {@code request.getRemoteAddr()} is always the proxy address; + * using it directly would collapse every user into one rate-limit bucket and let a single caller + * lock out the whole platform. + * + *

Forwarded headers are only honoured when the direct peer is a proxy we operate (loopback or a + * private/container address). A public peer therefore cannot spoof its address by sending the + * header itself. + */ +public final class ClientIp { + private static final String FORWARDED_FOR = "X-Forwarded-For"; + private static final String REAL_IP = "X-Real-IP"; + + private ClientIp() {} + + /** Returns the client address used for rate limiting and audit records. */ + public static String of(HttpServletRequest request) { + String peer = normalize(request.getRemoteAddr()); + if (!trustedProxy(peer)) return peer; + + // X-Real-IP is written by our own nginx from $remote_addr, so it cannot be spoofed by a client. + String real = normalize(request.getHeader(REAL_IP)); + if (ipLiteral(real)) return real; + + // Otherwise take the right-most X-Forwarded-For entry: that is the value our proxy appended. + // Anything further left came from the client and is not trustworthy. + String forwarded = lastValidForwardedFor(request.getHeader(FORWARDED_FOR)); + return forwarded == null ? peer : forwarded; + } + + private static String lastValidForwardedFor(String header) { + if (header == null || header.isBlank()) return null; + List parts = List.of(header.split(",")); + for (int i = parts.size() - 1; i >= 0; i--) { + String candidate = normalize(parts.get(i)); + if (ipLiteral(candidate)) return candidate; + } + return null; + } + + /** Trims whitespace, strips IPv6 brackets and unwraps IPv4-mapped IPv6 addresses. */ + static String normalize(String value) { + if (value == null) return ""; + String address = value.trim(); + if (address.isEmpty()) return ""; + if (address.startsWith("[")) { + int end = address.indexOf(']'); + if (end > 0) address = address.substring(1, end); + } + if (address.regionMatches(true, 0, "::ffff:", 0, 7)) address = address.substring(7); + return address.length() > 64 ? address.substring(0, 64) : address; + } + + /** + * True for both IPv4 and IPv6 literals. Guards {@link InetAddress#getByName} so a malformed + * header value can never trigger a DNS lookup. + */ + static boolean ipLiteral(String value) { + if (value == null || value.isEmpty()) return false; + boolean digitsAndDots = true; + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + if (!Character.isDigit(c) && c != '.') { + digitsAndDots = false; + break; + } + } + if (digitsAndDots) return value.indexOf('.') > 0; + // Conservative IPv6 check: hex digits, colons and at most one embedded IPv4 tail. + for (int i = 0; i < value.length(); i++) { + char c = value.charAt(i); + boolean ok = + Character.digit(c, 16) >= 0 || c == ':' || c == '.' || c == '%' || c == ']' || c == '['; + if (!ok) return false; + } + return value.indexOf(':') >= 0; + } + + /** True when the direct peer is a reverse proxy we operate rather than an arbitrary client. */ + static boolean trustedProxy(String peer) { + if (!ipLiteral(peer)) return false; + try { + InetAddress address = InetAddress.getByName(peer); + return address.isLoopbackAddress() + || address.isAnyLocalAddress() + || address.isSiteLocalAddress() + || sharedAddressSpace(peer); + } catch (Exception e) { + return false; + } + } + + /** RFC 6598 shared address space, used by container and overlay networks. */ + private static boolean sharedAddressSpace(String peer) { + if (!peer.startsWith("100.")) return false; + String[] parts = peer.split("\\."); + if (parts.length != 4) return false; + try { + int second = Integer.parseInt(parts[1]); + return second >= 64 && second <= 127; + } catch (NumberFormatException e) { + return false; + } + } +} diff --git a/backend/src/test/java/run/webup/platform/ClientIpTest.java b/backend/src/test/java/run/webup/platform/ClientIpTest.java new file mode 100644 index 0000000..3e36602 --- /dev/null +++ b/backend/src/test/java/run/webup/platform/ClientIpTest.java @@ -0,0 +1,90 @@ +package run.webup.platform; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +import jakarta.servlet.http.HttpServletRequest; +import org.junit.jupiter.api.Test; + +class ClientIpTest { + + private static HttpServletRequest request(String remoteAddr, String forwardedFor, String realIp) { + HttpServletRequest request = mock(HttpServletRequest.class); + when(request.getRemoteAddr()).thenReturn(remoteAddr); + when(request.getHeader("X-Forwarded-For")).thenReturn(forwardedFor); + when(request.getHeader("X-Real-IP")).thenReturn(realIp); + return request; + } + + @Test + void directPublicClientIsNeverRewrittenByHeaders() { + // A public peer must not be able to spoof its address. + assertEquals( + "203.0.113.9", + ClientIp.of(request("203.0.113.9", "1.2.3.4", "5.6.7.8"))); + } + + @Test + void trustedProxyResolvesRealClientFromRealIp() { + assertEquals( + "203.0.113.9", + ClientIp.of(request("172.19.0.5", null, "203.0.113.9"))); + } + + @Test + void trustedProxyFallsBackToForwardedFor() { + assertEquals( + "203.0.113.9", + ClientIp.of(request("172.19.0.5", "203.0.113.9", null))); + } + + @Test + void usesRightMostForwardedEntrySoClientCannotSpoofPrefix() { + // The client sent "1.2.3.4"; our proxy appended the real address on the right. + assertEquals( + "203.0.113.9", + ClientIp.of(request("172.19.0.5", "1.2.3.4, 203.0.113.9", null))); + } + + @Test + void separateClientsGetSeparateBuckets() { + // Regression: behind the proxy these used to both resolve to 172.19.0.5. + String first = ClientIp.of(request("172.19.0.5", null, "198.51.100.7")); + String second = ClientIp.of(request("172.19.0.5", null, "198.51.100.8")); + assertNotEquals(first, second); + } + + @Test + void loopbackProxyIsTrusted() { + assertEquals("203.0.113.9", ClientIp.of(request("127.0.0.1", null, "203.0.113.9"))); + assertEquals("203.0.113.9", ClientIp.of(request("::1", null, "203.0.113.9"))); + } + + @Test + void ipv4MappedIpv6IsUnwrapped() { + assertEquals( + "203.0.113.9", + ClientIp.of(request("::ffff:172.19.0.5", null, "::ffff:203.0.113.9"))); + } + + @Test + void bracketedIpv6IsUnwrapped() { + assertEquals("2001:db8::1", ClientIp.normalize("[2001:db8::1]")); + } + + @Test + void malformedForwardedValueFallsBackToPeerInsteadOfResolvingDns() { + assertEquals( + "172.19.0.5", + ClientIp.of(request("172.19.0.5", "not-an-ip", "also-not-an-ip"))); + } + + @Test + void blankAndNullInputsAreSafe() { + assertEquals("", ClientIp.normalize(null)); + assertEquals("", ClientIp.normalize(" ")); + assertFalse(ClientIp.ipLiteral("")); + assertFalse(ClientIp.trustedProxy("")); + assertEquals("172.19.0.5", ClientIp.of(request("172.19.0.5", " ", " "))); + } +} diff --git a/frontend/nginx.conf b/frontend/nginx.conf index e152b42..8aaf13e 100644 --- a/frontend/nginx.conf +++ b/frontend/nginx.conf @@ -4,26 +4,35 @@ server { root /usr/share/nginx/html; index index.html; server_tokens off; - client_max_body_size 1m; + client_max_body_size 26m; add_header X-Content-Type-Options nosniff always; add_header Referrer-Policy strict-origin-when-cross-origin always; add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com; img-src 'self' data: https:; connect-src 'self'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'" always; + # Oversized uploads are answered in the same JSON shape as the API instead of nginx's HTML page. + error_page 413 = @upload_too_large; + location @upload_too_large { + default_type application/json; + return 413 '{"message":"单文件不能超过 25MiB"}'; + } location /api/public/extensions/plugin-frame/ { # This response carries the backend's sandbox policy. The app shell remains non-frameable. add_header X-Content-Type-Options nosniff always; proxy_pass http://backend:8080; proxy_http_version 1.1; proxy_set_header Host $host; - proxy_set_header X-Forwarded-For ""; - proxy_set_header X-Real-IP ""; + # Overwrite rather than append: a client-supplied value must never reach the backend. The + # backend only reads these when the direct peer is a trusted proxy. + proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header X-Real-IP $remote_addr; } location /api/ { proxy_pass http://backend:8080; proxy_http_version 1.1; proxy_set_header Host $host; - # Backend intentionally does not trust user-supplied forwarded IP headers. - proxy_set_header X-Forwarded-For ""; - proxy_set_header X-Real-IP ""; + # Overwrite rather than append: a client-supplied value must never reach the backend. The + # backend only trusts these when the direct peer is a private/loopback proxy address. + proxy_set_header X-Forwarded-For $remote_addr; + proxy_set_header X-Real-IP $remote_addr; } location / { try_files $uri $uri/ /index.html; } } diff --git a/frontend/src/landing.css b/frontend/src/landing.css index 84e8024..b81926f 100644 --- a/frontend/src/landing.css +++ b/frontend/src/landing.css @@ -913,6 +913,10 @@ .landing-menu { display: none; } +/* Only rendered inside the collapsed mobile menu; desktop keeps the standalone 登录 link. */ +.landing-nav-login { + display: none; +} .mobile-break { display: none; } @@ -996,8 +1000,50 @@ } } @media (max-width: 850px) { + .landing-nav { + position: relative; + gap: 10px; + } + .landing-menu { + display: inline-flex; + margin-left: auto; + } .landing-nav nav { + position: absolute; + top: calc(100% + 1px); + left: 16px; + right: 16px; display: none; + flex-direction: column; + gap: 2px; + padding: 8px; + background: var(--landing-surface, #fff); + border: 1px solid var(--landing-border, #eef1f6); + border-radius: 12px; + box-shadow: 0 18px 40px #1d2d4814; + z-index: 40; + } + .landing-nav nav.expanded { + display: flex; + } + .landing-nav nav > a { + padding: 12px 14px; + border-radius: 8px; + font-size: 13px; + } + .landing-nav nav > a:hover { + background: var(--landing-accentSoft, #edf3ff); + } + .landing-nav nav .landing-nav-login { + display: block; + padding: 12px 14px; + border-radius: 8px; + font-size: 13px; + color: var(--landing-muted, #7a879b); + } + .landing-nav nav .landing-nav-login:hover { + background: var(--landing-accentSoft, #edf3ff); + color: var(--landing-accent, #3868f5); } .landing-hero { grid-template-columns: 1fr; diff --git a/frontend/src/views/Landing.vue b/frontend/src/views/Landing.vue index 4d32a7b..d914b8d 100644 --- a/frontend/src/views/Landing.vue +++ b/frontend/src/views/Landing.vue @@ -105,7 +105,13 @@ onMounted(async () => { 平台能力开发流程托管套餐常见问题 + >常见问题

登录