IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

¿Qué es IRC?

IRC (Internet Relay Chat), fundado a principios de los años 90, es un sistema de comunicación en tiempo real que permite chatear e interactuar en diferentes canales. Es como un espacio virtual donde se reúnen personas con intereses similares.

¿Por qué es importante IRC para desarrolladores y programadores?

Apoyo comunitario Seas principiante en la programación o desarrollador experimentado, IRC ofrece un espacio para hacer preguntas, obtener ayuda y compartir conocimiento.

Variedad de temas Encontrarás canales para casi cualquier lenguaje de programación y tema de desarrollo de software. Desde Python hasta Java, C# y JavaScript, existe una comunidad para cada lenguaje.

Discusiones en tiempo real A diferencia de los foros o listas de correo, IRC ofrece respuestas inmediatas y discusiones, lo que resulta especialmente útil cuando necesitas ayuda rápida con un problema difícil.

Construcción de red IRC es un lugar excelente para establecer contactos y conectar con personas afines de todo el mundo.

IRC y lenguajes de programación

Python Los desarrolladores de Python utilizan IRC para discutir los últimos avances u obtener ayuda con bibliotecas específicas.

Java Las comunidades de Java en IRC ofrecen soporte y comparten mejores prácticas para todo, desde Java SE hasta Java EE.

C# Los desarrolladores de C# encuentran en IRC canales dedicados a .NET, ASP.NET y otras tecnologías de Microsoft.

JavaScript Con la creciente popularidad del desarrollo web y Node.js, IRC es un lugar ideal para discutir frameworks de JavaScript y tecnologías frontend.

Cómo usar IRC Para empezar, necesitas un cliente IRC, como mIRC, HexChat o Irssi. Una vez instalado el cliente, conéctate a una red IRC como Libera.Chat, EFnet o DALnet y únete a canales que se ajusten a tus intereses.

Si te interesa el tema de IRC, consulta también la siguiente página: IRC-Mania.de – Tu portal sobre IRC

Los siguientes ejemplos muestran cómo establecer una conexión TCP simple a un servidor IRC en varios lenguajes de programación, registrar el nombre de usuario y unirse a un canal. Los ejemplos están intencionalmente simplificados y sirven como punto de partida para tu propio cliente IRC o script de monitoreo.

Consejo: Si prefieres trabajar directamente con bibliotecas y frameworks, encontrarás en el artículo IRC Bot Programmieren: Frameworks für Python, Node.js, Go & Rust una guía detallada para pydle, irc-framework, go-ircevent y el Rust irc crate.

Aquí encontrarás más artículos de IRC-Coding sobre programación.

Te mostraremos lo fácil que es conectarse a un servidor IRC con casi cualquier lenguaje de programación. Como ves en el ejemplo del bot IRC anterior, puedes expandir este ejemplo en un bot para automatizar muchas cosas.

Ejemplos de código: Conexión a servidor IRC en 10 lenguajes

Python

import socket
import time

SERVER = "irc.IRC-Mania.net"
PORT = 6667
NICK = "MeinBot"
USER = "meinbot"
CHANNEL = "#test"

def connect():
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect((SERVER, PORT))
    sock.sendall(f"NICK {NICK}\r\n".encode())
    sock.sendall(f"USER {USER} 0 * :Mein einfacher Bot\r\n".encode())
    time.sleep(2)
    sock.sendall(f"JOIN {CHANNEL}\r\n".encode())
    return sock

if __name__ == "__main__":
    sock = connect()
    while True:
        data = sock.recv(1024).decode(errors="ignore")
        if not data:
            break
        print(data.strip())

Explicación: El ejemplo utiliza el módulo socket de la biblioteca estándar de Python. Abre una conexión TCP al servidor IRC, envía el apodo y la identificación del usuario. Después de una breve pausa, se une a un canal e imprime todos los datos recibidos en la terminal.

C

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

int main() {
    struct addrinfo hints = {0}, *res;
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;

    getaddrinfo("irc.IRC-Mania.net", "6667", &hints, &res);
    int sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    connect(sock, res->ai_addr, res->ai_addrlen);
    freeaddrinfo(res);

    char buffer[1024];
    snprintf(buffer, sizeof(buffer), "NICK MeinBot\r\n");
    send(sock, buffer, strlen(buffer), 0);
    snprintf(buffer, sizeof(buffer), "USER meinbot 0 * :Mein einfacher Bot\r\n");
    send(sock, buffer, strlen(buffer), 0);
    sleep(2);
    snprintf(buffer, sizeof(buffer), "JOIN #test\r\n");
    send(sock, buffer, strlen(buffer), 0);

    while (recv(sock, buffer, sizeof(buffer) - 1, 0) > 0) {
        printf("%s", buffer);
        memset(buffer, 0, sizeof(buffer));
    }

    close(sock);
    return 0;
}

Explicación: El ejemplo en C utiliza la API de sockets BSD con getaddrinfo para resolver el nombre de host irc.IRC-Mania.net. Crea un socket TCP, se conecta al servidor y envía los comandos de registro IRC. Después de unirse al canal, las mensajes recibidas se muestran en un bucle.

C++

#include <iostream>
#include <boost/asio.hpp>

int main() {
    try {
        boost::asio::io_context io;
        boost::asio::ip::tcp::socket socket(io);
        boost::asio::ip::tcp::resolver resolver(io);
        auto endpoints = resolver.resolve("irc.IRC-Mania.net", "6667");
        boost::asio::connect(socket, endpoints);

        auto send = [&](const std::string& msg) {
            boost::asio::write(socket, boost::asio::buffer(msg + "\r\n"));
        };

        send("NICK MeinBot");
        send("USER meinbot 0 * :Mein einfacher Bot");
        std::this_thread::sleep_for(std::chrono::seconds(2));
        send("JOIN #test");

        char buffer[1024];
        while (true) {
            size_t len = socket.read_some(boost::asio::buffer(buffer));
            std::cout.write(buffer, len);
        }
    } catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

Explicación: El ejemplo en C++ utiliza Boost.Asio, una biblioteca ampliamente utilizada para operaciones de red e I/O asincrónico. Resuelve el nombre de host, establece la conexión y envía los comandos IRC. Para proyectos puros de C++20, también es posible usar std::net de la Networking TS, aunque aún no está disponible en todos los compiladores.

Java

import java.io.*;
import java.net.*;

public class IrcClient {
    public static void main(String[] args) throws Exception {
        String server = "irc.IRC-Mania.net";
        int port = 6667;
        String nick = "MeinBot";
        String channel = "#test";

        try (Socket socket = new Socket(server, port);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {

            out.println("NICK " + nick);
            out.println("USER meinbot 0 * :Mein einfacher Bot");
            Thread.sleep(2000);
            out.println("JOIN " + channel);

            String line;
            while ((line = in.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

Explicación: El ejemplo en Java utiliza java.net.Socket y los streams para entrada y salida. Envía los comandos con PrintWriter y lee las respuestas con BufferedReader. El bloque try-with-resources se encarga de cerrar la conexión automáticamente al final.

Node.js / JavaScript

const net = require('net');

const client = net.createConnection({ host: 'irc.IRC-Mania.net', port: 6667 }, () => {
    console.log('Verbunden');
    client.write('NICK MeinBot\r\n');
    client.write('USER meinbot 0 * :Mein einfacher Bot\r\n');
    setTimeout(() => {
        client.write('JOIN #test\r\n');
    }, 2000);
});

client.on('data', (data) => {
    console.log(data.toString());
});

client.on('end', () => {
    console.log('Verbindung geschlossen');
});

Explicación: El ejemplo de Node.js utiliza el módulo net. Después de establecer la conexión, se envían los comandos NICK y USER. Tras dos segundos, se dispara la entrada al canal. Los datos que llegan se muestran como cadena de texto en la terminal. Para aplicaciones en navegador, podrías usar WebSockets o un proxy IRC.

Rust

use std::io::{Read, Write};
use std::net::TcpStream;
use std::thread;
use std::time::Duration;

fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("irc.IRC-Mania.net:6667")?;
    stream.write_all(b"NICK MeinBot\r\n")?;
    stream.write_all(b"USER meinbot 0 * :Mein einfacher Bot\r\n")?;
    thread::sleep(Duration::from_secs(2));
    stream.write_all(b"JOIN #test\r\n")?;

    let mut buffer = [0u8; 1024];
    loop {
        let len = stream.read(&mut buffer)?;
        if len == 0 {
            break;
        }
        print!("{}", String::from_utf8_lossy(&buffer[..len]));
    }
    Ok(())
}

Explicación: El ejemplo de Rust usa std::net::TcpStream de la librería estándar. Establece la conexión, envía los comandos IRC y lee las respuestas en un bucle. String::from_utf8_lossy permite mostrar incluso secuencias UTF-8 incompletas o erróneas sin que el programa falle.

Go

package main

import (
    "bufio"
    "fmt"
    "net"
    "time"
)

func main() {
    conn, err := net.Dial("tcp", "irc.IRC-Mania.net:6667")
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    fmt.Fprintln(conn, "NICK MeinBot")
    fmt.Fprintln(conn, "USER meinbot 0 * :Mein einfacher Bot")
    time.Sleep(2 * time.Second)
    fmt.Fprintln(conn, "JOIN #test")

    reader := bufio.NewReader(conn)
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            break
        }
        fmt.Print(line)
    }
}

Explicación: El ejemplo de Go utiliza net.Dial y bufio.Reader. fmt.Fprintln añade automáticamente un salto de línea, que el servidor IRC espera como terminador. defer conn.Close() asegura que la conexión se cierre cuando finaliza el programa.

C#

using System;
using System.IO;
using System.Net.Sockets;
using System.Threading;

class IrcClient
{
    static void Main()
    {
        using var client = new TcpClient("irc.IRC-Mania.net", 6667);
        using var stream = client.GetStream();
        using var reader = new StreamReader(stream);
        using var writer = new StreamWriter(stream) { AutoFlush = true };

        writer.WriteLine("NICK MeinBot");
        writer.WriteLine("USER meinbot 0 * :Mein einfacher Bot");
        Thread.Sleep(2000);
        writer.WriteLine("JOIN #test");

        while (!reader.EndOfStream)
        {
            Console.WriteLine(reader.ReadLine());
        }
    }
}

Explicación: El ejemplo de C# emplea TcpClient y los envoltorios de stream StreamReader y StreamWriter. AutoFlush = true garantiza que cada línea se envíe inmediatamente al servidor. using asegura una liberación limpia de recursos.

Ruby

require 'socket'

server = 'irc.IRC-Mania.net'
port = 6667
nick = 'MeinBot'
channel = '#test'

socket = TCPSocket.new(server, port)
socket.puts "NICK #{nick}"
socket.puts "USER meinbot 0 * :Mein einfacher Bot"
sleep 2
socket.puts "JOIN #{channel}"

while line = socket.gets
  puts line
end

socket.close

Explicación: El ejemplo de Ruby usa TCPSocket de la librería estándar. puts envía automáticamente una línea con salto de línea. El bucle lee las líneas que llegan hasta que se cierre la conexión. Ruby es especialmente útil para prototipos rápidos y scripts de automatización.

PHP

<?php
$server = 'irc.IRC-Mania.net';
$port = 6667;
$nick = 'MeinBot';
$channel = '#test';

$socket = fsockopen($server, $port);
if (!$socket) {
    die("Verbindung fehlgeschlagen\n");
}

fwrite($socket, "NICK $nick\r\n");
fwrite($socket, "USER meinbot 0 * :Mein einfacher Bot\r\n");
sleep(2);
fwrite($socket, "JOIN $channel\r\n");

while (!feof($socket)) {
    echo fgets($socket, 1024);
}

fclose($socket);

Explicación: El ejemplo de PHP usa fsockopen para establecer una conexión TCP. fwrite envía los comandos IRC, fgets lee las respuestas línea por línea. Aunque PHP rara vez se usa para clientes IRC hoy en día, sigue siendo útil para escenarios de monitoreo e integración web.

IRC-Bouncer: ideas de programación y soluciones actuales

Un IRC-Bouncer es un programa que se mantiene conectado permanentemente a un servidor IRC y actúa como puente entre el servidor y tu cliente real. En lugar de hablar directamente con la red IRC desde tu portátil o móvil, te conectas al bouncer. Este conserva la conexión con el servidor, almacena los mensajes del tiempo en que estuviste desconectado y te permite chatear desde varios dispositivos al mismo tiempo.

¿Qué se puede programar en un bouncer?

• Almacenamiento de historial: Guarda todos los mensajes de canales y privados en una base de datos o archivo, para que puedas leer lo que perdiste después de reconectarte.
• Interfaz web: Crea una pequeña interfaz web donde puedas gestionar canales, mensajes y configuración desde el navegador.
• Notificaciones push: Envía alertas a correo electrónico, Messenger o servicios push móviles cuando te mencionen o recibas un mensaje privado.
• Logging y archivo: Implementa una función de búsqueda sobre logs antiguos, con filtros por canal, fecha o usuario.
• Soporte multi-usuario: Desarrolla un bouncer que atienda a varios usuarios simultáneamente, cada uno con su propio nick y canales.
• Proxy TLS: Cifra la conexión entre cliente y bouncer, incluso si el servidor solo comunica sin cifrado.
• Integración de bots: Combina bouncer y bot para que el bouncer ejecute comandos automatizados al mismo tiempo.

Soluciones de bouncers actuales

• ZNC: Probablemente el bouncer IRC más conocido y flexible. Ofrece módulos, logging, múltiples usuarios y una comunidad amplia.
• The Lounge: Un cliente IRC moderno basado en web y bouncer en uno. Se ejecuta en el navegador y almacena el historial en el servidor.
• Soju: Un bouncer ligero pensado especialmente para desarrolladores y usuarios técnicos que se integra bien en configuraciones personalizadas.
• pounce: Un bouncer muy ligero enfocado en simplicidad y funcionamiento multi-usuario.
• Quassel: Un cliente IRC distribuido donde un núcleo permanece siempre conectado y distintos clientes se pueden conectar después.

Si quieres configurar o comprar un bouncer, encontrarás guías de instalación y ofertas actuales en IRC-Mania.de/bouncer.

Notas importantes sobre los ejemplos

• Reemplaza MiBot, mibot y #test con tus propios valores.
• El puerto 6667 es el puerto estándar para conexiones IRC sin cifrado. Para TLS utiliza el puerto 6697 con una conexión cifrada.
• Muchos servidores requieren una dirección de correo electrónico o un registro para mantener nicknames permanentes. Consulta los detalles en la documentación de tu red IRC elegida.
• Para implementar un cliente IRC completo aún necesitas funcionalidades como manejo de PING-PONG, envío de mensajes, gestión de errores y TLS.

Encontrarás más tutoriales, listas de servidores y consejos sobre IRC en IRC-Mania.de.

¿Qué es un IRCD o servidor IRC?

IRCD significa IRC Daemon y es el software servidor que opera una red IRC. Un IRCD acepta conexiones de clientes, gestiona canales y usuarios, y reenvía mensajes a otros servidores en la misma red. Sin IRCD no hay red IRC posible, ya que es quien implementa el protocolo y coordina la comunicación.

Los IRCDs típicamente se escriben en lenguajes cercanos al sistema que permiten alto rendimiento y muchas conexiones simultáneas:

• C: UnrealIRCd, Bahamut, Hybrid, ircd-ratbox, Charybdis, ircd-seven
• C++: InspIRCd, Anope (Services)
• Go: Ergo (anteriormente Oragono), un IRCD moderno con servicios integrados y características similares a Matrix
• Rust: Algunas implementaciones experimentales y modernas
• Java: Varios proyectos de servidor antiguos o especializados

Hoy en día los IRCDs más conocidos son UnrealIRCd e InspIRCd, porque son flexibles, ampliamente utilizados y bien documentados. Bahamut fue durante mucho tiempo el servidor detrás de DALnet. Ergo es particularmente interesante para nuevos proyectos, ya que tiene registro de nicknames y canales integrado directamente.

Encontrarás más información sobre diferentes IRCDs, su configuración y diferencias en IRC-Mania.de/ircds.

Los modos de canal IRC más importantes

Los modos de canal son interruptores que determinan cómo pueden comportarse los usuarios en un canal. Se establecen con el comando MODE #canal +.... Los modos exactos varían ligeramente entre diferentes IRCDs, pero los siguientes son prácticamente universales:

• +t (Topic-Lock): Solo los operadores del canal pueden cambiar el tema. Previene que usuarios normales lo modifiquen.
• +n (No External Messages): Los usuarios fuera del canal no pueden enviar mensajes a este. Mantiene la comunicación restringida a los miembros.
• +m (Moderated): Solo usuarios con estatus como operador o voz pueden escribir en el canal. Los demás solo pueden leer.
• +i (Invite-only): El canal solo es visible y accesible para usuarios invitados. Entrar requiere un INVITE.
• +k (Key): El canal está protegido con contraseña. Se entra únicamente con JOIN #canal contraseña.
• +l (Limit): Limita el número máximo de usuarios en el canal. Nuevos usuarios pueden entrar cuando hay espacio.
• +s (Secret): El canal es secreto y no aparece en listas públicas. WHOIS tampoco lo muestra.
• +p (Private): El canal está marcado como privado. Similar a +s, pero aún aparece en listas con información incompleta.
• +b (Ban): Previene que ciertos usuarios entren al canal. Los bans funcionan con máscaras como *!*@host.
• +v (Voice): Otorga a un usuario el derecho de hablar en un canal moderado (+m). En el chat el usuario se identifica con un + antes del nombre.
• +o (Operator): Hace operador del canal a un usuario. Los operadores pueden establecer bans, expulsar usuarios, cambiar temas y gestionar modos. Se identifican con @ antes del nombre.
• +r (Registered only): Solo usuarios registrados y autenticados pueden entrar al canal.
• +c (No Colors): Previene formatos de color en el canal para mantener legibilidad y claridad.
• +C (No CTCP): Bloquea solicitudes CTCP en el canal para prevenir abusos como CTCP-flooding.
• +N (No Nickchanges): Los usuarios en el canal no pueden cambiar su nickname mientras están en él.
• +u (No Unregistered): Solo usuarios registrados pueden escribir o entrar en el canal.
• +z (Op-only messages): Los mensajes de usuarios baneados o silenciados solo son visibles para operadores.
• +O (Oper only): Solo operadores de red pueden entrar al canal.
• +M (Registered speak): Solo usuarios registrados pueden escribir en el canal, pero usuarios no registrados pueden entrar y leer.

Encontrarás una lista detallada de todos los modos de canal IRCD con explicaciones en IRC-Mania.de/alle-ircd-channelmodes-deutsch.

IRC-Services: Anope, Atheme y más

IRC-Services son servicios que corren además del IRCD y proporcionan funcionalidades que el IRCD mismo no ofrece. Los servicios más conocidos incluyen registro de nicknames y canales, autenticación y herramientas administrativas.

Los paquetes de IRC-Services más importantes son:

• Anope: El paquete de servicios más difundido. Ofrece NickServ, ChanServ, HostServ, MemoServ y OperServ. Anope está escrito en C++ y soporta muchos IRCDs.
• Atheme: Un paquete de servicios moderno y alternativo, que se enfoca especialmente en seguridad y flexibilidad. También incluye NickServ, ChanServ, HostServ y GroupServ.
• BitlBee: Un servicio especial que usa IRC como pasarela hacia otros protocolos de chat como XMPP, Matrix o Mastodon. También puedes usarlo como un bouncer IRC.
• ChatServices: Un paquete de servicios antiguo que raramente se implementa en nuevos proyectos.
• IRCServices: Otro paquete histórico que sirvió como base para desarrollos posteriores.

Las cuentas de servicios típicas son:

• NickServ: Gestiona registro y autenticación de nicknames.
• ChanServ: Gestiona registro de canales, permisos, modos y temas.
• HostServ: Asigna hosts virtuales o vhosts.
• MemoServ: Permite dejar mensajes para otros usuarios.
• OperServ: Herramientas administrativas para operadores de red.

Una visión general de IRC-Services actuales, su configuración y diferencias la encuentras en IRC-Mania.de/ircservices.

Los comandos IRC más importantes

IRC se controla mediante comandos basados en texto. Los comandos más importantes que deberías conocer como usuario, desarrollador o administrador son:

• /connect o /server: Te conecta a un servidor IRC.
• /nick: Cambia tu nickname.
• /user: Envía información de usuario al conectarte, generalmente automático desde el cliente.
• /join: Entra en un canal, por ejemplo /join #canal.
• /part: Sales de un canal, opcionalmente con un motivo /part #canal Hasta luego.
• /quit: Cierra la conexión con el servidor, opcionalmente con un mensaje.
• /msg o /privmsg: Envía un mensaje privado a un usuario o canal.
• /notice: Envía un mensaje que no espera respuesta, frecuentemente para notificaciones automáticas.
• /whois: Muestra información sobre un usuario.
• /whowas: Muestra información sobre un nickname usado recientemente.
• /mode: Establece modos para usuarios o canales, por ejemplo /mode #canal +o Nickname.
• /topic: Establece o muestra el tema de un canal.
• /kick: Expulsa a un usuario de un canal, solo para operadores.
• /ban: Establece un ban, generalmente a través de ChanServ o /mode #canal +b máscara.
• /invite: Invita a un usuario a un canal solo por invitación.
• /oper: Te autentica como operador de red, requiere permisos oper configurados.
• /ping y /pong: Mantienen la conexión activa y verifican la accesibilidad.
• /pass: Envía una contraseña al conectarse, por ejemplo para SASL o contraseñas de servidor.
• /away: Te marca como ausente con un mensaje de estado.
• /list: Muestra una lista de canales públicos.
• /names: Muestra los usuarios en un canal.
• /motd: Muestra el mensaje del día del servidor.
• /rules: Muestra las reglas del servidor.
• /ns o /nickserv: Interactúa con NickServ, por ejemplo para registro o autenticación.
• /cs o /chanserv: Interactúa con ChanServ, por ejemplo para registro de canales y gestión de permisos.

Encontrarás una de las páginas IRC alemanas más antiguas y activamente mantenidas con una referencia completa de comandos en IRC-Mania.de/ircbefehle.

IRCv3, SASL y extensiones modernas

IRC está lejos de estar muerto. Con IRCv3 existe un proceso de estandarización que adapta el protocolo a las necesidades contemporáneas. Las extensiones IRCv3 más importantes que todo desarrollador debería conocer son:

• CAP (Capability Negotiation): Permite al cliente y al servidor negociar qué extensiones se soportan antes del login. Sin CAP no hay SASL, sin extended-join y sin mensajes en batch.
• SASL: Autenticación durante el establecimiento de la conexión. Los mecanismos más comunes son PLAIN y EXTERNAL. EXTERNAL utiliza certificados de cliente y es especialmente seguro.
• away-notify: El servidor informa automáticamente al cliente cuando otro usuario cambia su estado Away. Evita tener que usar /whois constantemente.
• account-notify: Notifica cuando un usuario se conecta o desconecta de una cuenta de servicio.
• extended-join: Al entrar en un canal, el cliente recibe directamente el nombre de cuenta y el nombre real del usuario.
• multi-prefix: Un cliente ve todos los prefijos de estado de un usuario, no solo el más alto. Por ejemplo, se transmite @+Nick en lugar de solo @Nick.
• batch: Múltiples mensajes relacionados pueden marcarse como un batch, lo cual es especialmente útil para bridges y clientes.
• message-tags: Permite añadir metadatos a los mensajes, como reacciones, indicadores de edición o IDs personalizados.
• reply-client-tag: Permite respuestas similares a threading en mensajes, como en las plataformas modernas.
• setname: Posibilita cambiar el nombre real durante la sesión sin necesidad de reconectarse.
• account-tag: Marca los mensajes con el nombre de cuenta del remitente, lo que es práctico para moderación y scripts.

Quien trabaje seriamente con IRC debe conectarse con CAP LS 302 y negociar deliberadamente las capacidades que ofrece el servidor.

Topología de red: Netsplits, U-Lines y Linking

Una red IRC no es un servidor único, sino una estructura distribuida de múltiples servidores interconectados. Esta es una diferencia fundamental respecto a plataformas centralizadas como Discord o Slack.

• Server-Link: Dos IRCDs se conectan entre sí mediante un enlace cifrado o sin cifrar. La configuración se denomina C:Lines, H:Lines o bloques Connect, dependiendo del IRCD.
• U-Lines: Servidores designados como servidores de servicios que pueden ejecutar acciones especiales como establecer modos. NickServ y ChanServ típicamente funcionan en servidores U-Lined.
• O-Lines: Determinan quién es operador de red. Los derechos de operador no son para el uso diario, sino para la administración de servidores.
• Netsplit: Cuando la conexión entre dos servidores se interrumpe, la red se divide temporalmente. Los usuarios en una parte desaparecen para la otra parte. Tras reconectarse, los servidores sincronizan sus estados y ocurre el netsplit-join.
• Split Riding: Un ataque donde alguien entra en un canal durante un netsplit y se otorga a sí mismo derechos de operador antes de que los servidores se reconecten. Las contramedidas incluyen TS (Timestamp) y diversos mecanismos de protección de los IRCDs.
• Services-Server: Un servidor especial o un proceso integrado mediante U-Lines que proporciona servicios de nickname, canal y administración.

Para administradores, comprender linking, netsplits y TS es la diferencia entre una red estable y un servidor caótico.

Prefijos de usuario y canal: Founder, Admin, Halfop, Voice

Los canales IRC tienen una jerarquía que va más allá de los clásicos @ y +. Los IRCDs modernos y los servicios soportan varios niveles:

• ~ (Tilde): Founder. El propietario de un canal registrado, frecuentemente con derechos especiales como establecer flags de ChanServ.
• & (Ampersand): Admin. Puede hacer casi todo como un operador, pero no degradar a otros admins o al founder.
• @ (At): Operator. Puede expulsar, banear, establecer temas y cambiar modos.
• % (Percent): Halfop. Puede hablar en caso de emergencia, expulsar y moderar brevemente si es necesario, pero con menos derechos que un operador.
• + (Plus): Voice. Puede hablar en un canal moderado (+m) y frecuentemente se marca como miembro de confianza.

Los modos correspondientes son:

• +q para Founder
• +a para Admin
• +o para Operator
• +h para Halfop
• +v para Voice

No todos los IRCDs soportan todos estos niveles. InspIRCd y UnrealIRCd los conocen, IRCDs más pequeños o redes antiguas se conforman con +o y +v.

Seguridad en IRC para desarrolladores: Cloaks, CertFP y DNSBL

Quien administre un servidor o un bot importante debe ir más allá de lo básico:

• Cloaking / Vhost: Una cloak oculta la IP real u hostname de un usuario. En lugar de user@123-45-67-89.example.net, se ve algo como user@irc/member/MaxMustermann. Los vhosts se configuran mediante HostServ o el servidor.
• CertFP: Certificate Fingerprint. Un cliente se conecta con un certificado TLS de cliente. El servidor o los servicios almacenan la huella digital. Así es posible autenticarse sin contraseña pero de forma segura.
• SASL EXTERNAL: Combina SASL con CertFP. Especialmente seguro porque no se transmite contraseña.
• DNSBL: DNS-based Blackhole List. Los servidores pueden verificar IPs contra listas conocidas de proxies o spam y rechazar conexiones de listas negras.
• Open Proxy Scanner: Muchas redes escanean las conexiones entrantes en busca de proxies abiertos para prevenir abusos.
• K-Line, G-Line, Z-Line, D-Line: Diferentes niveles de ban. K-Line batea en un servidor, G-Line en toda la red, Z-Line bloquea rangos de IP inmediatamente a nivel de protocolo, D-Line es un doble ban o ban DNS en toda la red.
• Shun: Un ban “silencioso” donde el usuario sigue conectado pero no puede enviar mensajes. Útil para perturbadores que se quieren observar.
• ConnThrottle: Muchos IRCDs tienen mecanismos anti-flood que bloquean demasiadas conexiones por unidad de tiempo desde la misma IP.
• Secure-Only: Con el user-mode +z o channel-mode +z, los servidores pueden configurarse para permitir solo a usuarios cifrados con TLS.

DCC, CTCP y compartición de archivos sobre IRC

Además del chat de texto normal, IRC ofrece conexiones cliente-a-cliente directas:

• CTCP (Client-to-Client Protocol): Mensajes especiales que los clientes procesan, no el servidor. Ejemplos son CTCP VERSION, CTCP TIME, CTCP PING y CTCP ACTION. Este último se usa para /me.
• DCC CHAT: Un chat directo entre dos clientes sin que el servidor retransmita los mensajes. Útil para conversaciones cifradas o independientes del servidor.
• DCC SEND: Permite la transferencia directa de archivos entre dos clientes. El remitente ofrece el archivo, el destinatario confirma y establece una conexión directa.
• DCC RESUME: Permite reanudar transferencias interrumpidas. Importante con archivos grandes o conexiones inestables.
• DCC XMIT: Una extensión para transferencias cifradas o comprimidas, pero solo soportada por pocos clientes.

Hoy DCC es menos común porque NAT, firewalls y TLS-proxy lo dificultan. Para archivos ocasionales o chats directos sigue siendo práctico.

Scripts y extensiones en clientes IRC

Muchos clientes IRC permiten automatización y extensiones. Para un desarrollador, este es uno de los aspectos más atractivos de IRC:

• mIRC Scripting: mIRC tiene su propio lenguaje de script. Con él es posible crear bots, respuestas automatizadas, temas visuales, herramientas de registro y juegos. Muchos scripts históricos de IRC provienen de la era de mIRC.
• Irssi Perl: Irssi soporta scripts en Perl. Existen miles de scripts para logging, notificaciones, juegos, integraciones y moderación.
• WeeChat Scripts: WeeChat ofrece scripting en Python, Perl, Ruby, Lua, Tcl y JavaScript. Especialmente populares son las extensiones para gestión de buffers, puentes a Matrix y herramientas para la operación diaria.
• ZNC Modules: ZNC está escrito en C++ y se extiende mediante módulos en Python, Perl o C++. Los módulos pueden realizar logging, filtrado, notificaciones push e integraciones externas.
• The Lounge Plugins: El ecosistema de The Lounge permite integrar temas y extensiones, aunque su sistema de plugins no es tan profundo como el de Irssi o WeeChat.
• Eggdrop: Eggdrop es un bot IRC clásico escrito en C que se extiende con scripts en Tcl. Se utiliza frecuentemente como bouncer, bot y protección de canal simultáneamente.

IRC versus plataformas de chat modernas

IRC es descentralizado, basado en texto y abierto. Esto lo diferencia fundamentalmente de las plataformas modernas:

• Discord: Centralizado, propietario, con chat de voz, compartición de pantalla y potentes herramientas de moderación. IRC es más ligero, abierto y requiere menos recursos.
• Matrix: Descentralizado y federado, con cifrado de extremo a extremo moderno y soporte para multimedia. Matrix es más complejo, pero se ajusta mejor a los requisitos modernos. IRC es más eficiente y tiene menos overhead.
• Slack: Orientado a empresas, centralizado, con muchas integraciones. IRC es gratuito, abierto y popular en comunidades técnicas que valoran el control.
• Telegram/Signal: Mensajeros con infraestructura centralizada o federada. Son más amigables, pero no tan abiertos como IRC.
• Ventajas de IRC: Sin registro obligatorio, protocolos abiertos, ligero, escalable, muchas opciones de auto-hospedaje, enorme relevancia histórica.
• Desventajas de IRC: Sin compartición de pantalla nativa, sin historial incorporado sin bouncer, curva de aprendizaje pronunciada para principiantes, menos características modernas sin IRCv3.

Cultura de IRC: Netsplits, Lurk y guerras de OP

IRC tiene una cultura propia que va más allá de la técnica:

• Lurking: Muchos usuarios permanecen horas en canales sin escribir activamente. Leen, ayudan ocasionalmente y son parte de la comunidad. Lurking es completamente aceptado.
• Idling: Similar al lurking, pero aún más pasivo. Un idling deliberado puede estar asociado con sistemas de proyectos como los de FreeNode o canales comunitarios para mostrar presencia.
• Netsplits: Quien lleva tiempo en IRC los experimenta. Un netsplit a menudo se comenta con memes como “The Internet is broken”.
• OP-Wars: Históricamente había conflictos por derechos de operador, especialmente en canales no registrados. Con Services y estado de fundador, estos problemas son menos comunes hoy, pero no han desaparecido.
• ChanStats: Muchas redes recopilan estadísticas sobre actividad, palabras, líneas y horarios. Esto genera rankings internos y competencias.
• Historia de IRC: IRC fue desarrollado en 1988 por Jarkko Oikarinen y es anterior a la World Wide Web. Ha moldeado significativamente la cultura de internet temprana.
• Cultura de memes: Muchos memes de internet como “lol”, “afk”, “brb”, “asl” o “rtfm” tienen sus raíces en IRC.

Arquitectura de bots IRC: Event-Loop, Parser y Plugins

Un buen bot IRC es más que un simple script de sockets. La arquitectura consta de varias capas:

• Capa de conexión: Responsable de la conexión TCP, handshake TLS, PING/PONG y reconexión. Debe manejar desconexiones de forma limpia.
• Parser: Convierte mensajes IRC entrantes en eventos internos. Un formato típico es :nick!user@host COMMAND target :message. El parser debe separar prefijo, comando, parámetros y trailer.
• Event-Loop: Distribuye eventos entrantes a handlers. Ejemplos incluyen on_message, on_join, on_part, on_nick_change, on_kick y on_disconnect.
• Command-Router: Asigna comandos del usuario como !help o !weather a funciones correspondientes. Generalmente con prefijo y verificación de permisos.
• Plugin-System: Carga módulos externos en tiempo de ejecución. Los plugins deben estar aislados y comunicarse con el bot a través de una API clara.
• Data Layer: Almacena configuración, logs, datos de usuarios o estadísticas de canales. SQLite es suficiente para bots pequeños, PostgreSQL para configuraciones más grandes.
• Rate-Limiter: Previene que el bot envíe demasiados mensajes y sea inundado por el servidor. A menudo utiliza el algoritmo de Token Bucket.
• Permission-System: Verifica si un usuario puede ejecutar ciertos comandos. Canales, estado de operador o registro de nickname pueden servir como criterios.

Quien quiera operar un bot propio seriamente debe basarse en un framework establecido y desarrollar plugins propios sobre él, en lugar de construir todo desde cero.

Configurar tu propio IRCD: primeros pasos

Para verdaderos desarrolladores, configurar un servidor IRC propio es un rite of passage. Los pasos típicos son:

1. Elegir IRCD: Los principiantes a menudo comienzan con UnrealIRCd o InspIRCd porque hay muchos tutoriales. Ergo es una buena opción si deseas services integrados.
2. Instalar el servidor: Ya sea mediante gestor de paquetes, imagen Docker o compilación manual desde el código fuente.
3. Ajustar la configuración: El archivo de configuración principal contiene nombre del servidor, info del admin, puertos de escucha, certificados TLS, oper-lines y bloques de enlace.
4. Integrar Services: Para registro de nicknames y canales, se instala Anope o Atheme y se conectan mediante U-Lines.
5. Añadir un Bouncer: ZNC o The Lounge permite mantenerse conectado permanentemente y chatear desde múltiples dispositivos.
6. Firewall y DNS: Abrir puertos 6667 y 6697, establecer registros DNS para irc.tudominio.es y opcionalmente configurar DNS inverso.
7. Pruebas y apertura: Primero probar localmente, luego dar acceso a amigos, luego potencialmente hacerlo público. Siempre respetando reglas del servidor y medidas anti-spam.
8. Monitoreo: Rotar logs, supervisar conexiones, instalar regularmente actualizaciones del IRCD y services.

Un IRCD propio es ideal para pequeñas comunidades, aprendizaje o como espacio de comunicación aislado para equipos.

Hall of Fame: personas que han moldeado IRC y me han inspirado

IRC no es un protocolo anónimo, sino el resultado de décadas de trabajo de individuos. Esta sección es un pequeño tributo a desarrolladores, admins y visionarios que han formado significativamente el ecosistema de IRC.

Descubrí IRC siendo muy joven, inicialmente solo para intercambiar imágenes o archivos, pero ya entonces me fascinaban los desarrolladores que habían construido proyectos tan grandes. Codemastr, Andrew Church y otros. Estos son mis favoritos:

• Jarkko Oikarinen: El inventor de IRC. En 1988 desarrolló la primera versión en el Centro Finlandés de Computación Científica. Sin él, no habría IRC, no habría mIRC, no habría ZNC ni ninguna de las comunidades que conocemos hoy.
• Andrew Church: Responsable de IRCServices, uno de los primeros y más influyentes paquetes de IRC Services. Su trabajo sentó las bases para el registro de nicknames y canales tal como lo conocemos hoy con NickServ y ChanServ.
• Carsten V. Munk (stskeeps): Figura central en UnrealIRCd durante mucho tiempo. Impulsó características, lógica de red y modularidad que convirtieron a UnrealIRCd en uno de los IRCDs más conocidos.
• codemastr: Uno de los principales desarrolladores de larga trayectoria de UnrealIRCd. Fue fundamental en la estabilización y expansión del código, moldeando la arquitectura sobre la que muchos servidores aún funcionan hoy.
• Darren Reed: Desarrollador de ircd y posteriormente de Bahamut de DALnet. Su trabajo influyó fuertemente en el lado del servidor de IRC durante los años 90.
• Roger Espel Llima: Creó EPIC, uno de los clientes IRC más antiguos y flexibles. EPIC fue pionero en muchas características que luego aparecieron en otros clientes.
• Khaled Mardam-Bey: Desarrollador de mIRC, el cliente de Windows que acercó IRC a millones de usuarios en los 90s y 2000s. mIRC Scripting moldeó toda una generación de bots y scripts IRC.
• Timo Sirainen: Desarrollador de Irssi y posteriormente de Dovecot. Irssi sigue siendo uno de los clientes IRC de terminal más populares para desarrolladores y administradores de servidores.
• Sébastien Helleu (FlashCode): Iniciador y desarrollador principal de WeeChat. Construyó uno de los clientes de terminal más modernos y extensibles.
• Robey Pointer: Autor original de Eggdrop, el bot IRC clásico en C con scripting en Tcl. Eggdrop fue durante mucho tiempo el estándar para protección de canales y automatización.
• El equipo Anope: Muchos mantenedores a lo largo de los años han convertido a Anope en el paquete de services más extendido. Hoy conecta casi todo IRCD con una infraestructura confiable de registro.
• El equipo Atheme: Con desarrolladores como nenolod y jilles, Atheme creó una alternativa a Anope enfocada especialmente en seguridad y características modernas.
• Daniel Oaks y el equipo Ergo: Daniel Oaks impulsó IRCv3 y el IRCD moderno Ergo (anteriormente Oragono). Ergo demuestra que IRC puede seguir evolucionando en 2026.
• El equipo ZNC: Mantenedores y colaboradores como psychon y prozac han convertido a ZNC en el bouncer IRC estándar.
• Wilmer van der Gaast: Iniciador de BitlBee, el puente IRC a otros protocolos de chat. BitlBee demuestra que IRC puede servir como interfaz central para toda la comunicación.
• El equipo The Lounge: Desarrolladores web modernos que con The Lounge demostraron que IRC puede ser contemporáneo y amigable en el navegador.

Moxquiz tampoco puede faltar en un hall of fame: el bot IRC alemán de trivia que en muchos canales ha generado rondas emocionantes de preguntas y competencias internas. Demuestra que los bots de IRC no se usan solo para administración o file sharing, sino también como entretenimiento y experiencia comunitaria.

Esta lista es naturalmente incompleta. Detrás de cada IRCD, cada cliente y cada service hay docenas o cientos de colaboradores que a lo largo de los años aportaron correcciones de bugs, documentación, soporte e ideas. Quien usa IRC hoy se para sobre los hombros de esta comunidad.

Lo que debes tener en cuenta al programar con IRC

Si escribes tus propios clientes o bots para IRC, hay varios detalles que es fácil pasar por alto pero que son cruciales para un funcionamiento estable:

• PING/PONG: Los servidores IRC envían regularmente solicitudes PING. Si no respondes con PONG, el servidor cierra la conexión. Así que manejar PING/PONG es obligatorio.
• Longitud de mensajes: Un mensaje IRC no puede exceder 512 bytes incluyendo \r\n. Los mensajes más largos deben dividirse.
• Límites de velocidad: Enviar demasiados mensajes en poco tiempo provoca un bloqueo temporal (Excess Flood). Añade pausas, especialmente para mensajes automatizados.
• Codificación: La mayoría de redes modernas usan UTF-8. Asegúrate de que la entrada y salida estén codificadas de forma consistente.
• Prefiere TLS: Para producción, usa preferentemente el puerto 6697 con TLS/SSL para proteger la conexión y las credenciales.
• Manejo de errores: Las conexiones de red pueden fallar. Una lógica de reconexión y un manejo de errores limpio hacen que tu bot sea robusto.
• Respeta las reglas del servidor: Cada red IRC tiene sus propias normas para bots, nicknames y canales. Cúmplelas para evitar ser expulsado o baneado.
• Sin secretos en el código: Las contraseñas, claves API o credenciales de servicios de nicknames nunca van en el código fuente, sino en variables de entorno o en un sistema de configuración separado.

Encontrarás más tutoriales, listas de servidores y consejos sobre IRC en IRC-Mania.de. Para preguntas sobre el protocolo, comandos y comportamiento de servidores, también vale la pena consultar IRC-FAQ.de.

FAQ: IRC, Programación y Seguridad (Internet Relay Chat)

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert