1. import java.io.IOException;
  2. import java.net.ServerSocket;
  3. import java.net.Socket;
  4. import java.util.HashMap;
  5. import java.util.Map;
  7. public class HeaderLimiter {
  9. private static final int PORT = 8080; // Port to listen on
  10. private static final int MAX_HEADER_SIZE = 4096; // Maximum size for each header
  11. private static final int MAX_HEADERS = 100; // Maximum number of headers allowed
  13. private ServerSocket serverSocket;
  15. public HeaderLimiter() throws IOException {
  16. serverSocket = new ServerSocket(PORT);
  17. }
  19. public void start() throws IOException {
  20. System.out.println("Header Limiter started on port " + PORT);
  21. while (true) {
  22. Socket clientSocket = serverSocket.accept();
  23. processRequest(clientSocket);
  24. clientSocket.close();
  25. }
  26. }
  28. private void processRequest(Socket clientSocket) throws IOException {
  29. try (java.io.InputStream inputStream = clientSocket.getInputStream();
  30. java.io.OutputStream outputStream = clientSocket.getOutputStream()) {
  32. StringBuilder request = new StringBuilder();
  33. int buffer;
  34. while ((buffer = inputStream.read()) != -1) {
  35. request.append((char) buffer);
  36. }
  38. String requestString = request.toString();
  39. String[] headers = parseHeaders(requestString);
  41. if (headers != null) {
  42. validateHeaders(headers, outputStream);
  43. } else {
  44. // Handle invalid request
  45. outputStream.write("Invalid Request".getBytes());
  46. outputStream.flush();
  47. }
  48. }
  49. }
  51. private String[] parseHeaders(String requestString) {
  52. String[] headers = requestString.split("\r\n");
  53. //Basic parsing, adjust as needed for more complex requests.
  54. return headers;
  55. }
  57. private void validateHeaders(String[] headers, OutputStream outputStream) {
  58. Map<String, Integer> headerCounts = new HashMap<>();
  60. for (String header : headers) {
  61. String[] parts = header.split(": ");
  62. if (parts.length == 2) {
  63. String name = parts[0].trim();
  64. String value = parts[1].trim();
  66. if (name.isEmpty() || value.isEmpty()) continue;
  68. if (name.length() > MAX_HEADER_SIZE) {
  69. outputStream.write("Header Name too long".getBytes());
  70. outputStream.flush();
  71. return;
  72. }
  74. headerCounts.put(name, headerCounts.getOrDefault(name, 0) + 1);
  76. if (headerCounts.get(name) > MAX_HEADERS) {
  77. outputStream.write("Too many headers".getBytes());
  78. outputStream.flush();
  79. return;
  80. }
  81. }
  82. }
  83. }
  85. public void stop() throws IOException {
  86. serverSocket.close();
  87. System.out.println("Header Limiter stopped.");
  88. }
  90. public static void main(String[] args) throws IOException {
  91. HeaderLimiter limiter = new HeaderLimiter();
  92. limiter.start();
  94. //Keep the program running to accept connections. In a real application you might have a more sophisticated shutdown mechanism.
  95. try {
  96. Thread.sleep(10000); //Run for 10 seconds
  97. } catch (InterruptedException e) {
  98. //Handle interruption
  99. } finally {
  100. limiter.stop();
  101. }
  102. }
  103. }

Add your comment