Seguridad en Supabase

// Esto es correcto y seguro en el cliente
const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
);
 
// Esta query solo devuelve datos que las politicas RLS permiten
const { data } = await supabase.from('profiles').select('*');

// SOLO en el servidor: Server Components, Server Actions, Route Handlers
import { createClient } from '@supabase/supabase-js';
 
const supabaseAdmin = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
);
 
// Esta query devuelve TODOS los datos, sin importar RLS
const { data } = await supabaseAdmin.from('profiles').select('*');

# .env.local
 
# Públicas (se incluyen en el bundle del cliente)
NEXT_PUBLIC_SUPABASE_URL=tu-url-aca
NEXT_PUBLIC_SUPABASE_ANON_KEY=tu-anon-key-aca
 
# Privadas (solo accesibles en el servidor)
SUPABASE_SERVICE_ROLE_KEY=tu-service-role-key-aca
SUPABASE_DB_URL=tu-connection-string-aca

# Buscar posibles secrets hardcodeados en tu codigo
grep -r "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9" --include="*.ts" --include="*.tsx" .
grep -r "service_role" --include="*.ts" --include="*.tsx" . | grep -v ".env"
grep -r "SUPABASE_SERVICE_ROLE" --include="*.ts" --include="*.tsx" . | grep -v "process.env"

# Verificar que .env.local esta en .gitignore
cat .gitignore | grep ".env"

https://tudominio.com
https://www.tudominio.com
https://staging.tudominio.com

# Ejemplo: solo permitir acceso desde tu servidor de produccion
# y desde tu IP de desarrollo
Allowed IPs:
  - 203.0.113.50/32  (servidor de produccion)
  - 198.51.100.14/32 (tu IP de desarrollo)

// Seguro: el SDK parametriza los valores automáticamente
const { data } = await supabase
  .from('products')
  .select('*')
  .eq('category', userInput);
 
// Seguro: incluso con input malicioso, el SDK lo escapa
const maliciousInput = "'; DROP TABLE products; --";
const { data: safe } = await supabase
  .from('products')
  .select('*')
  .eq('category', maliciousInput);
// Se busca literalmente el string, no se ejecuta como SQL

-- MAL: concatenar input del usuario directamente
CREATE FUNCTION search_products(search_term text)
RETURNS SETOF products AS $$
  SELECT * FROM products WHERE name LIKE '%' || search_term || '%';
$$ LANGUAGE sql;

-- BIEN: usar parametros o funciones seguras de PostgreSQL
CREATE FUNCTION search_products(search_term text)
RETURNS SETOF products AS $$
  SELECT * FROM products
  WHERE name ILIKE '%' || regexp_replace(search_term, '[%_\\]', '\\\0', 'g') || '%';
$$ LANGUAGE sql SECURITY DEFINER;

JWT expiry: 3600  (1 hora - recomendado para apps con datos sensibles)

// Validacion adicional en el frontend antes de enviar a Supabase
function validatePassword(password: string): string | null {
  if (password.length < 12) return 'La contraseña debe tener al menos 12 caracteres';
  if (!/[A-Z]/.test(password)) return 'Debe incluir al menos una mayúscula';
  if (!/[0-9]/.test(password)) return 'Debe incluir al menos un número';
  if (!/[^A-Za-z0-9]/.test(password)) return 'Debe incluir al menos un símbolo';
  return null;
}

import { createServerClient } from '@supabase/ssr';
import { cookies } from 'next/headers';
import { redirect } from 'next/navigation';
 
async function getSupabaseUser() {
  const cookieStore = await cookies();
 
  const supabase = createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return cookieStore.getAll();
        },
        setAll(cookiesToSet) {
          cookiesToSet.forEach(({ name, value, options }) => {
            cookieStore.set(name, value, options);
          });
        },
      },
    }
  );
 
  const { data: { user }, error } = await supabase.auth.getUser();
 
  if (error || !user) {
    redirect('/login');
  }
 
  return { supabase, user };
}

// next.config.ts
const nextConfig = {
  async headers() {
    return [
      {
        source: '/(.*)',
        headers: [
          {
            key: 'X-Frame-Options',
            value: 'DENY',
          },
          {
            key: 'X-Content-Type-Options',
            value: 'nosniff',
          },
          {
            key: 'Referrer-Policy',
            value: 'strict-origin-when-cross-origin',
          },
          {
            key: 'Permissions-Policy',
            value: 'camera=(), microphone=(), geolocation=()',
          },
          {
            key: 'Strict-Transport-Security',
            value: 'max-age=63072000; includeSubDomains; preload',
          },
          {
            key: 'Content-Security-Policy',
            value: [
              "default-src 'self'",
              "script-src 'self' 'unsafe-inline' 'unsafe-eval'",
              `connect-src 'self' ${process.env.NEXT_PUBLIC_SUPABASE_URL} wss://*.supabase.co`,
              "img-src 'self' data: blob:",
              "style-src 'self' 'unsafe-inline'",
              "font-src 'self'",
              "frame-ancestors 'none'",
            ].join('; '),
          },
        ],
      },
    ];
  },
};
 
export default nextConfig;

-- Tabla de roles
CREATE TABLE public.user_roles (
  id uuid DEFAULT gen_random_uuid() PRIMARY KEY,
  user_id uuid REFERENCES auth.users(id) ON DELETE CASCADE,
  role text NOT NULL CHECK (role IN ('admin', 'editor', 'viewer')),
  UNIQUE(user_id, role)
);
 
ALTER TABLE public.user_roles ENABLE ROW LEVEL SECURITY;
 
-- Solo admins pueden ver los roles
CREATE POLICY "Admins ven roles"
  ON public.user_roles
  FOR SELECT
  USING (
    EXISTS (
      SELECT 1 FROM public.user_roles
      WHERE user_id = auth.uid()
        AND role = 'admin'
    )
  );
 
-- Política en otra tabla que usa roles
CREATE POLICY "Solo admins y editores pueden crear contenido"
  ON public.posts
  FOR INSERT
  WITH CHECK (
    EXISTS (
      SELECT 1 FROM public.user_roles
      WHERE user_id = auth.uid()
        AND role IN ('admin', 'editor')
    )
  );

-- Simular un usuario especifico para testear RLS
SET request.jwt.claim.sub = 'uuid-del-usuario-de-prueba';
SET request.jwt.claim.role = 'authenticated';
 
-- Ejecutar query como ese usuario
SELECT * FROM public.profiles;
 
-- Resetear
RESET request.jwt.claim.sub;
RESET request.jwt.claim.role;

// lib/logger.ts
type LogLevel = 'info' | 'warn' | 'error';
 
interface LogEntry {
  level: LogLevel;
  message: string;
  context?: Record<string, unknown>;
  timestamp: string;
}
 
function log(level: LogLevel, message: string, context?: Record<string, unknown>) {
  const entry: LogEntry = {
    level,
    message,
    context,
    timestamp: new Date().toISOString(),
  };
 
  // En produccion, envia a tu servicio de logging
  if (process.env.NODE_ENV === 'production') {
    // Sentry, LogRocket, Datadog, etc.
    console.log(JSON.stringify(entry));
  } else {
    console.log(`[${level.toUpperCase()}] ${message}`, context);
  }
}
 
export const logger = {
  info: (msg: string, ctx?: Record<string, unknown>) => log('info', msg, ctx),
  warn: (msg: string, ctx?: Record<string, unknown>) => log('warn', msg, ctx),
  error: (msg: string, ctx?: Record<string, unknown>) => log('error', msg, ctx),
};

// Uso en un Server Action
import { logger } from '@/lib/logger';
 
export async function deleteAccountAction() {
  'use server';
 
  const { supabase, user } = await getSupabaseUser();
 
  logger.info('Solicitud de eliminación de cuenta', { userId: user.id });
 
  const { error } = await supabase.from('profiles').delete().eq('user_id', user.id);
 
  if (error) {
    logger.error('Error eliminando cuenta', { userId: user.id, error: error.message });
    throw new Error('No se pudo eliminar la cuenta');
  }
 
  logger.info('Cuenta eliminada exitosamente', { userId: user.id });
}

-- Rotar la anon key fuerza a todos los clientes a actualizarse
-- Rotar la service_role key invalida cualquier acceso backend con la key vieja
 
-- Revocar todas las sesiones de un usuario comprometido
SELECT auth.revoke_all_sessions('uuid-del-usuario');