-
-
-
- Get started by editing{" "}
-
- src/app/page.js -- . -
- - - Save and see your changes instantly. - -
+
);
}
diff --git a/src/hooks/usePingService.js b/src/hooks/usePingService.js
new file mode 100644
index 0000000..85c8492
--- /dev/null
+++ b/src/hooks/usePingService.js
@@ -0,0 +1,108 @@
+import { useState, useCallback, useRef } from 'react';
+
+export function usePingService() {
+ const [isLoading, setIsLoading] = useState(false);
+ const [results, setResults] = useState(null);
+ const [error, setError] = useState(null);
+ const [rateLimitInfo, setRateLimitInfo] = useState(null);
+ const abortControllerRef = useRef(null);
+
+ const executePing = useCallback(async (formData) => {
+ // Cancelar request anterior si existe
+ if (abortControllerRef.current) {
+ abortControllerRef.current.abort();
+ }
+
+ // Crear nuevo AbortController
+ abortControllerRef.current = new AbortController();
+
+ setIsLoading(true);
+ setError(null);
+ setResults(null);
+
+ try {
+ const response = await fetch('/api/ping', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify(formData),
+ signal: abortControllerRef.current.signal,
+ });
+
+ const data = await response.json();
+
+ // Actualizar información de rate limit desde headers
+ if (response.headers.get('X-RateLimit-Limit')) {
+ setRateLimitInfo({
+ limit: parseInt(response.headers.get('X-RateLimit-Limit')),
+ remaining: parseInt(response.headers.get('X-RateLimit-Remaining')),
+ resetTime: parseInt(response.headers.get('X-RateLimit-Reset')),
+ });
+ }
+
+ if (!response.ok) {
+ throw new Error(data.message || `HTTP ${response.status}: ${response.statusText}`);
+ }
+
+ setResults(data);
+
+ // Actualizar rate limit info desde la respuesta si está disponible
+ if (data.rateLimit) {
+ setRateLimitInfo(data.rateLimit);
+ }
+
+ } catch (err) {
+ // No mostrar error si fue cancelado
+ if (err.name !== 'AbortError') {
+ setError(err.message);
+ }
+ } finally {
+ setIsLoading(false);
+ abortControllerRef.current = null;
+ }
+ }, []);
+
+ const cancelPing = useCallback(() => {
+ if (abortControllerRef.current) {
+ abortControllerRef.current.abort();
+ abortControllerRef.current = null;
+ setIsLoading(false);
+ }
+ }, []);
+
+ const clearResults = useCallback(() => {
+ setResults(null);
+ setError(null);
+ }, []);
+
+ const fetchStatus = useCallback(async () => {
+ try {
+ const response = await fetch('/api/status');
+ const data = await response.json();
+
+ if (data.clientInfo?.rateLimit) {
+ setRateLimitInfo(data.clientInfo.rateLimit);
+ }
+
+ return data;
+ } catch (err) {
+ console.error('Failed to fetch status:', err);
+ return null;
+ }
+ }, []);
+
+ return {
+ // Estado
+ isLoading,
+ results,
+ error,
+ rateLimitInfo,
+
+ // Acciones
+ executePing,
+ cancelPing,
+ clearResults,
+ fetchStatus,
+ };
+}
diff --git a/src/lib/config.js b/src/lib/config.js
new file mode 100644
index 0000000..8fa09fc
--- /dev/null
+++ b/src/lib/config.js
@@ -0,0 +1,119 @@
+// Configuración del servicio de ping
+export const PING_CONFIG = {
+ // Rate limiting
+ RATE_LIMIT: {
+ MAX_REQUESTS: parseInt(process.env.RATE_LIMIT_MAX) || 10,
+ WINDOW_MS: parseInt(process.env.RATE_LIMIT_WINDOW_MS) || 60 * 1000, // 1 minuto
+ },
+
+ // Límites de ping
+ PING_LIMITS: {
+ MAX_COUNT: parseInt(process.env.PING_MAX_COUNT) || 10,
+ MIN_COUNT: 1,
+ MAX_TIMEOUT: parseInt(process.env.PING_MAX_TIMEOUT) || 10000, // 10 segundos
+ MIN_TIMEOUT: 1000, // 1 segundo
+ DEFAULT_COUNT: 4,
+ DEFAULT_TIMEOUT: 5000, // 5 segundos
+ },
+
+ // Configuración de seguridad
+ SECURITY: {
+ BLOCK_PRIVATE_IPS: true,
+ BLOCK_LOCALHOST: true,
+ BLOCK_RESERVED_RANGES: true,
+ ALLOWED_PROTOCOLS: ['ICMP'],
+ },
+
+ // Configuración de red
+ NETWORK: {
+ MAX_CONCURRENT_PINGS: 5,
+ PING_INTERVAL_MS: 1000, // Intervalo entre pings individuales
+ MAX_HOSTNAME_LENGTH: 253,
+ MAX_LABEL_LENGTH: 63,
+ },
+
+ // Headers de respuesta
+ HEADERS: {
+ INCLUDE_RATE_LIMIT_HEADERS: true,
+ INCLUDE_SECURITY_HEADERS: true,
+ CORS_ENABLED: true,
+ },
+
+ // Logging y debugging
+ DEBUG: {
+ LOG_REQUESTS: process.env.NODE_ENV === 'development',
+ LOG_RATE_LIMITS: process.env.NODE_ENV === 'development',
+ INCLUDE_RAW_OUTPUT: true,
+ }
+};
+
+// Validador de configuración
+export function validateConfig() {
+ const errors = [];
+
+ if (PING_CONFIG.RATE_LIMIT.MAX_REQUESTS <= 0) {
+ errors.push('MAX_REQUESTS must be greater than 0');
+ }
+
+ if (PING_CONFIG.PING_LIMITS.MAX_COUNT > 50) {
+ errors.push('MAX_COUNT should not exceed 50 for performance reasons');
+ }
+
+ if (PING_CONFIG.PING_LIMITS.MAX_TIMEOUT > 30000) {
+ errors.push('MAX_TIMEOUT should not exceed 30 seconds');
+ }
+
+ if (errors.length > 0) {
+ throw new Error(`Configuration validation failed: ${errors.join(', ')}`);
+ }
+
+ return true;
+}
+
+// Configuración específica por entorno
+export function getEnvironmentConfig() {
+ const env = process.env.NODE_ENV || 'development';
+
+ const envConfigs = {
+ development: {
+ RATE_LIMIT: {
+ MAX_REQUESTS: 20, // Más permisivo en desarrollo
+ WINDOW_MS: 60 * 1000,
+ },
+ DEBUG: {
+ LOG_REQUESTS: true,
+ LOG_RATE_LIMITS: true,
+ INCLUDE_RAW_OUTPUT: true,
+ }
+ },
+
+ production: {
+ RATE_LIMIT: {
+ MAX_REQUESTS: 10, // Más restrictivo en producción
+ WINDOW_MS: 60 * 1000,
+ },
+ DEBUG: {
+ LOG_REQUESTS: false,
+ LOG_RATE_LIMITS: false,
+ INCLUDE_RAW_OUTPUT: false,
+ }
+ },
+
+ test: {
+ RATE_LIMIT: {
+ MAX_REQUESTS: 100, // Sin límites en tests
+ WINDOW_MS: 60 * 1000,
+ },
+ DEBUG: {
+ LOG_REQUESTS: false,
+ LOG_RATE_LIMITS: false,
+ INCLUDE_RAW_OUTPUT: false,
+ }
+ }
+ };
+
+ return {
+ ...PING_CONFIG,
+ ...envConfigs[env]
+ };
+}
diff --git a/src/lib/rate-limiter.js b/src/lib/rate-limiter.js
new file mode 100644
index 0000000..5726b50
--- /dev/null
+++ b/src/lib/rate-limiter.js
@@ -0,0 +1,100 @@
+import NodeCache from 'node-cache';
+import { PING_CONFIG } from './config.js';
+
+export class RateLimiter {
+ constructor(options = {}) {
+ // Usar configuración por defecto o personalizada
+ this.limit = options.limit || PING_CONFIG.RATE_LIMIT.MAX_REQUESTS;
+ this.windowMs = options.windowMs || PING_CONFIG.RATE_LIMIT.WINDOW_MS;
+
+ // Cache con TTL automático
+ this.cache = new NodeCache({
+ stdTTL: this.windowMs / 1000,
+ checkperiod: 60 // revisar cada 60 segundos
+ });
+ }
+
+ async checkLimit(identifier) {
+ const key = `rate_limit:${identifier}`;
+ const now = Date.now();
+ const windowStart = now - this.windowMs;
+
+ // Obtener datos actuales del cache
+ let data = this.cache.get(key) || {
+ requests: [],
+ resetTime: now + this.windowMs
+ };
+
+ // Filtrar requests dentro de la ventana de tiempo
+ data.requests = data.requests.filter(timestamp => timestamp > windowStart);
+
+ // Verificar si se excede el límite
+ const requestCount = data.requests.length;
+ const allowed = requestCount < this.limit;
+
+ if (allowed) {
+ // Agregar la nueva request
+ data.requests.push(now);
+
+ // Si es la primera request en esta ventana, actualizar resetTime
+ if (data.requests.length === 1) {
+ data.resetTime = now + this.windowMs;
+ }
+
+ // Guardar en cache
+ this.cache.set(key, data, this.windowMs / 1000);
+ }
+
+ return {
+ allowed,
+ limit: this.limit,
+ remaining: Math.max(0, this.limit - requestCount - (allowed ? 1 : 0)),
+ resetTime: data.resetTime,
+ requestCount: requestCount + (allowed ? 1 : 0)
+ };
+ }
+
+ // Método para obtener estadísticas de un cliente
+ getStats(identifier) {
+ const key = `rate_limit:${identifier}`;
+ const data = this.cache.get(key);
+
+ if (!data) {
+ return {
+ limit: this.limit,
+ remaining: this.limit,
+ requestCount: 0,
+ resetTime: Date.now() + this.windowMs
+ };
+ }
+
+ const now = Date.now();
+ const windowStart = now - this.windowMs;
+ const validRequests = data.requests.filter(timestamp => timestamp > windowStart);
+
+ return {
+ limit: this.limit,
+ remaining: Math.max(0, this.limit - validRequests.length),
+ requestCount: validRequests.length,
+ resetTime: data.resetTime
+ };
+ }
+
+ // Método para limpiar el cache manualmente
+ clear() {
+ this.cache.flushAll();
+ }
+
+ // Método para obtener todas las estadísticas (útil para debugging)
+ getAllStats() {
+ const keys = this.cache.keys();
+ const stats = {};
+
+ keys.forEach(key => {
+ const identifier = key.replace('rate_limit:', '');
+ stats[identifier] = this.getStats(identifier);
+ });
+
+ return stats;
+ }
+}
diff --git a/src/lib/validators.js b/src/lib/validators.js
new file mode 100644
index 0000000..147c5b0
--- /dev/null
+++ b/src/lib/validators.js
@@ -0,0 +1,149 @@
+import ipRegex from 'ip-regex';
+
+export function validateIP(target) {
+ if (!target || typeof target !== 'string') {
+ return {
+ valid: false,
+ message: 'Target must be a valid string'
+ };
+ }
+
+ // Limpiar espacios en blanco
+ const cleanTarget = target.trim();
+
+ if (cleanTarget.length === 0) {
+ return {
+ valid: false,
+ message: 'Target cannot be empty'
+ };
+ }
+
+ // Verificar si es una IP válida (IPv4 o IPv6)
+ if (ipRegex().test(cleanTarget)) {
+ // Validaciones adicionales para IPs
+ if (isPrivateOrReservedIP(cleanTarget)) {
+ return {
+ valid: false,
+ message: 'Private, loopback, or reserved IP addresses are not allowed'
+ };
+ }
+
+ return {
+ valid: true,
+ type: 'ip',
+ message: 'Valid IP address'
+ };
+ }
+
+ // Si no es IP, verificar si es un hostname válido
+ if (isValidHostname(cleanTarget)) {
+ // Verificar que no sea localhost o dominios locales
+ if (isLocalHostname(cleanTarget)) {
+ return {
+ valid: false,
+ message: 'Local hostnames are not allowed'
+ };
+ }
+
+ return {
+ valid: true,
+ type: 'hostname',
+ message: 'Valid hostname'
+ };
+ }
+
+ return {
+ valid: false,
+ message: 'Invalid IP address or hostname format'
+ };
+}
+
+function isPrivateOrReservedIP(ip) {
+ // Rangos de IPs privadas y reservadas que no deberíamos permitir
+ const privateRanges = [
+ /^127\./, // Loopback
+ /^10\./, // Private class A
+ /^172\.(1[6-9]|2[0-9]|3[01])\./, // Private class B
+ /^192\.168\./, // Private class C
+ /^169\.254\./, // Link-local
+ /^224\./, // Multicast
+ /^0\./, // Reserved
+ /^255\./, // Broadcast
+ /^::1$/, // IPv6 loopback
+ /^fe80:/, // IPv6 link-local
+ /^fc00:/, // IPv6 private
+ /^fd00:/ // IPv6 private
+ ];
+
+ return privateRanges.some(range => range.test(ip));
+}
+
+function isValidHostname(hostname) {
+ // Verificar longitud
+ if (hostname.length > 253) {
+ return false;
+ }
+
+ // Patrón para hostname válido (RFC 1123)
+ const hostnameRegex = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
+
+ if (!hostnameRegex.test(hostname)) {
+ return false;
+ }
+
+ // Verificar que no termine con punto
+ if (hostname.endsWith('.')) {
+ return false;
+ }
+
+ // Verificar que cada parte del hostname no sea demasiado larga
+ const parts = hostname.split('.');
+ return parts.every(part => part.length <= 63 && part.length > 0);
+}
+
+function isLocalHostname(hostname) {
+ const localHostnames = [
+ 'localhost',
+ 'localhost.localdomain',
+ 'local',
+ 'internal',
+ 'intranet'
+ ];
+
+ const lowerHostname = hostname.toLowerCase();
+
+ // Verificar hostnames exactos
+ if (localHostnames.includes(lowerHostname)) {
+ return true;
+ }
+
+ // Verificar dominios .local
+ if (lowerHostname.endsWith('.local')) {
+ return true;
+ }
+
+ // Verificar si termina en .localhost
+ if (lowerHostname.endsWith('.localhost')) {
+ return true;
+ }
+
+ return false;
+}
+
+export function sanitizeTarget(target) {
+ if (typeof target !== 'string') {
+ return '';
+ }
+
+ return target.trim().toLowerCase();
+}
+
+export function isValidTimeout(timeout) {
+ const timeoutNum = parseInt(timeout);
+ return !isNaN(timeoutNum) && timeoutNum >= 1000 && timeoutNum <= 30000;
+}
+
+export function isValidCount(count) {
+ const countNum = parseInt(count);
+ return !isNaN(countNum) && countNum >= 1 && countNum <= 10;
+}
diff --git a/src/middleware.js b/src/middleware.js
new file mode 100644
index 0000000..71664aa
--- /dev/null
+++ b/src/middleware.js
@@ -0,0 +1,38 @@
+import { NextResponse } from 'next/server';
+
+export function middleware(request) {
+ // Crear la respuesta
+ const response = NextResponse.next();
+
+ // Agregar headers de seguridad
+ response.headers.set('X-Content-Type-Options', 'nosniff');
+ response.headers.set('X-Frame-Options', 'DENY');
+ response.headers.set('X-XSS-Protection', '1; mode=block');
+ response.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin');
+
+ // Headers específicos para API
+ if (request.nextUrl.pathname.startsWith('/api/')) {
+ response.headers.set('Access-Control-Allow-Origin', '*');
+ response.headers.set('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+ response.headers.set('Access-Control-Allow-Headers', 'Content-Type');
+
+ // Manejar preflight requests
+ if (request.method === 'OPTIONS') {
+ return new Response(null, { status: 200, headers: response.headers });
+ }
+ }
+
+ return response;
+}
+
+export const config = {
+ matcher: [
+ /*
+ * Match all request paths except for the ones starting with:
+ * - _next/static (static files)
+ * - _next/image (image optimization files)
+ * - favicon.ico (favicon file)
+ */
+ '/((?!_next/static|_next/image|favicon.ico).*)',
+ ],
+};
+
+
+
+
+
-
-
-
+
+
+ 🏓 API Ping Service +
++ Test network connectivity to any IP address or hostname with our secure ping service. + Rate limited for fair usage and designed with modern security practices. +
+