IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was ist IRC?

IRC ( Internet Relay Chat), gegründet in den frühen 90er Jahren, ist ein Echtzeit-Kommunikationssystem, das es ermöglicht, in verschiedenen Kanälen (Channels) zu chatten und sich auszutauschen. Es ist wie ein virtueller Raum, in dem Menschen mit ähnlichen Interessen zusammenkommen.

Warum ist IRC für Entwickler und Programmierer wichtig?

Community-Unterstützung Egal ob du neu in der Welt der Programmierung bist oder ein erfahrener Entwickler, IRC bietet einen Raum, um Fragen zu stellen, Hilfe zu bekommen und Wissen zu teilen.

Vielfalt der Themen Du findest Kanäle für nahezu jede Programmiersprache und jedes Softwareentwicklungsthema. Von Python über Java bis hin zu C# und JavaScript – für jede Sprache gibt es eine Community.

Echtzeit-Diskussionen Im Gegensatz zu Foren oder E-Mail-Listen bietet IRC sofortige Antworten und Diskussionen, was besonders nützlich ist, wenn du schnell Hilfe bei einem kniffligen Problem brauchst.

Netzwerk aufbauen IRC ist ein großartiger Ort, um Kontakte zu knüpfen und sich mit Gleichgesinnten aus der ganzen Welt zu vernetzen.

IRC und Programmiersprachen

Python Python-Entwickler nutzen IRC, um über neueste Entwicklungen zu diskutieren oder Hilfe zu spezifischen Bibliotheken zu erhalten. Java Java-Communitys auf IRC bieten Unterstützung und teilen Best Practices für alles von Java SE bis hin zu Java EE. **C# C#-Entwickler finden auf IRC Kanäle, die sich auf .NET, ASP.NET und andere Microsoft-Technologien konzentrieren. JavaScript Mit der wachsenden Beliebtheit von Webentwicklung und Node.js ist der IRC ein idealer Ort, um über JavaScript-Frameworks und Frontend-Technologien zu diskutieren.

Wie du IRC nutzen kannst Um loszulegen, benötigst du einen IRC-Client, wie z.B. mIRC, HexChat oder Irssi. Sobald du den Client installiert hast, verbinde dich mit einem IRC-Netzwerk wie Libera.Chat, EFnet oder DALnet und tritt Kanälen bei, die deinen Interessen entsprechen.

Wenn Dich das Thema IRC interessiert, schaue Dir auch die folgende Seite an: IRC-Mania.de – Dein Portal rund um IRC

Die folgenden Beispiele zeigen, wie Du in verschiedenen Programmiersprachen eine einfache TCP‑Verbindung zu einem IRC‑Server aufbaust, den Benutzernamen registrierst und einem Kanal beitrittst. Die Beispiele sind bewusst einfach gehalten und eignen sich als Ausgangspunkt für einen eigenen IRC‑Client oder ein Monitoring‑Script.

Tipp: Wer direkt mit Bibliotheken und Frameworks arbeiten möchte, findet im Artikel IRC Bot Programmieren: Frameworks für Python, Node.js, Go & Rust eine detaillierte Anleitung für pydle, irc‑framework, go‑ircevent und den Rust‑irc‑crate.

Du findest hier auch weitere IRC-Coding-Artikel zur Programmierung.

Hier möchten wir Dir zeigen, wie einfach es ist, mit fast jeder Programmiersprache eine Verbindung zu einem IRC-Server aufzunehmen. Wie Du oben an dem IRC-BOT Beispiel siehst, kannst Du dieses Beispiel zu einem Bot ausbauen, um viele Dinge zu automatisieren.

Code‑Beispiele: IRC‑Server‑Verbindung in 10 Sprachen

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())

Erklärung: Das Beispiel nutzt das socket‑Modul aus der Python‑Standardbibliothek. Es öffnet eine TCP‑Verbindung zum IRC‑Server, sendet den Nickname und den Benutzer‑Identifikation. Nach einer kurzen Wartezeit tritt es einem Kanal bei und gibt alle empfangenen Daten im Terminal aus.

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;
}

Erklärung: Das C‑Beispiel verwendet die BSD‑Socket‑API mit getaddrinfo, um den Hostnamen irc.IRC-Mania.net aufzulösen. Es erstellt einen TCP‑Socket, verbindet sich mit dem Server und sendet die IRC‑Registrierungsbefehle. Nach dem Kanalbeitritt werden empfangene Nachrichten in einer Schleife ausgegeben.

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;
}

Erklärung: Das C++‑Beispiel nutzt Boost.Asio, eine weit verbreitete Bibliothek für Netzwerk‑ und asynchrone I/O. Es löst den Hostnamen auf, baut die Verbindung auf und sendet die IRC‑Befehle. Für reine C++20‑Projekte kann auch std::net aus der Networking‑TS verwendet werden, die sich aber noch nicht in allen Compilern befindet.

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);
            }
        }
    }
}

Erklärung: Das Java‑Beispiel verwendet java.net.Socket und die Streams für Ein‑ und Ausgabe. Es sendet die Befehle mit PrintWriter und liest Antworten mit BufferedReader. Der try‑with‑resources‑Block sorgt dafür, dass die Verbindung am Ende automatisch geschlossen wird.

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');
});

Erklärung: Das Node.js‑Beispiel nutzt das net‑Modul. Nach dem Verbindungsaufbau werden NICK und USER gesendet. Nach zwei Sekunden wird der Kanalbeitritt ausgelöst. Eingehende Daten werden als String im Terminal ausgegeben. Für Browser‑Anwendungen könnte man WebSockets oder einen IRC‑Proxy verwenden.

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(())
}

Erklärung: Das Rust‑Beispiel verwendet std::net::TcpStream aus der Standardbibliothek. Es baut die Verbindung auf, sendet die IRC‑Befehle und liest die Antworten in einer Schleife. String::from_utf8_lossy erlaubt es, auch unvollständige oder fehlerhafte UTF‑8‑Sequenzen anzuzeigen.

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)
    }
}

Erklärung: Das Go‑Beispiel nutzt net.Dial und bufio.Reader. fmt.Fprintln fügt automatisch ein Newline‑Zeichen hinzu, das der IRC‑Server als Zeilenende erwartet. Der defer conn.Close() stellt sicher, dass die Verbindung beim Beenden des Programms geschlossen wird.

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());
        }
    }
}

Erklärung: Das C#‑Beispiel verwendet TcpClient und die Stream‑Wrapper StreamReader/StreamWriter. AutoFlush = true sorgt dafür, dass jede Zeile sofort an den Server gesendet wird. using sorgt für eine saubere Ressourcenfreigabe.

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

Erklärung: Das Ruby‑Beispiel nutzt TCPSocket aus der Standardbibliothek. puts sendet automatisch eine Zeile mit Zeilenumbruch. Die Schleife liest eingehende Zeilen, bis die Verbindung geschlossen wird. Ruby eignet sich besonders gut für schnelle Prototypen und Automationsscripts.

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);

Erklärung: Das PHP‑Beispiel verwendet fsockopen, um eine TCP‑Verbindung herzustellen. fwrite sendet die IRC‑Befehle, fgets liest die Antworten zeilenweise. Auch wenn PHP heute selten für IRC‑Clients verwendet wird, ist es für Monitoring‑ oder Web‑Integrationsszenarien nützlich.

IRC-Bouncer: Programmierideen und aktuelle Lösungen

Ein IRC-Bouncer ist ein Programm, das dauerhaft mit einem IRC-Server verbunden bleibt und als Brücke zwischen Server und Deinem eigentlichen Client fungiert. Statt direkt vom Laptop oder Handy mit dem IRC-Netzwerk zu sprechen, verbindest Du Dich mit dem Bouncer. Der Bouncer hält die Verbindung zum Server aufrecht, speichert Nachrichten aus der Zeit, in der Du offline warst, und erlaubt es, von mehreren Geräten gleichzeitig zu chatten.

Was kann man an einem Bouncer programmieren?

• Backlog-Speicher: Speichere alle Kanal- und Privatnachrichten in einer Datenbank oder Datei, damit Du nach dem Wiederverbinden lesen kannst, was Du verpasst hast.
• Web-Interface: Baue eine kleine Web-Oberfläche, über die man Kanäle, Nachrichten und Einstellungen im Browser verwalten kann.
• Push-Notifications: Sende Benachrichtigungen an E-Mail, Messenger oder Mobile-Push-Services, wenn Dein Name erwähnt wird oder eine private Nachricht eingeht.
• Logging und Archiv: Schreibe eine Suchfunktion über alte Logs, inklusive Filter nach Kanal, Datum oder Benutzer.
• Multi-User-Support: Entwickle einen Bouncer, der mehrere Benutzer mit eigenen Nicknames und Kanälen gleichzeitig bedient.
• TLS-Proxy: Verschlüssele die Verbindung zwischen Client und Bouncer, auch wenn der Server selbst nur unverschlüsselt kommuniziert.
• Bot-Integration: Kombiniere Bouncer und Bot, sodass der Bouncer gleichzeitig automatisierte Befehle ausführt.

Aktuelle Bouncer-Lösungen

• ZNC: Der wohl bekannteste und flexibelste IRC-Bouncer. Er bietet Module, Logging, mehrere Benutzer und eine große Community.
• The Lounge: Ein moderner, webbasierter IRC-Client und Bouncer in einem. Er läuft im Browser und speichert den Verlauf serverseitig.
• Soju: Ein schlanker Bouncer, der vor allem für Entwickler und technische Benutzer gedacht ist und sich gut in eigene Setups integrieren lässt.
• pounce: Ein leichtgewichtiger Bouncer mit Fokus auf Einfachheit und Mehrbenutzerbetrieb.
• Quassel: Ein verteilter IRC-Client, bei dem ein Core ständig verbunden bleibt und verschiedene Clients später andocken können.

Wer einen Bouncer selbst aufsetzen oder kaufen möchte, findet auf IRC-Mania.de/bouncer Installationsanleitungen und aktuelle Angebote.

Wichtige Hinweise zu den Beispielen

• Ersetze MeinBot, meinbot und #test durch eigene Werte.
• Port 6667 ist der Standard‑Port für unverschlüsselte IRC‑Verbindungen. Für TLS nutze Port 6697 und eine verschlüsselte Verbindung.
• Viele Server verlangen eine E‑Mail‑Adresse oder eine Registrierung für dauerhafte Nicknames. Details dazu findest Du bei Deinem gewählten IRC‑Netzwerk.
• Für einen vollständigen IRC‑Client fehlen noch Funktionen wie PING‑PONG‑Behandlung, Nachrichten senden, Fehlerbehandlung und TLS.

Weitere Tutorials, Server‑Listen und Tipps rund um IRC findest Du auf IRC-Mania.de.

Was ist ein IRCD bzw. IRCServer?

IRCD steht für IRC Daemon und ist die Server-Software, die ein IRC-Netzwerk betreibt. Ein IRCD nimmt Verbindungen von Clients entgegen, verwaltet Kanäle und Benutzer und leitet Nachrichten an andere Server im selben Netzwerk weiter. Ohne IRCD gibt es kein IRC-Netzwerk, da er das Protokoll umsetzt und die Kommunikation koordiniert.

IRCDs werden meist in systemnahen Sprachen geschrieben, die hohe Performance und gleichzeitige Verbindungen erlauben:

• C: UnrealIRCd, Bahamut, Hybrid, ircd-ratbox, Charybdis, ircd-seven
• C++: InspIRCd, Anope (Services)
• Go: Ergo (ehemals Oragono), ein moderner IRCD mit integrierten Services und Matrix-ähnlichen Features
• Rust: Einige experimentelle und moderne Implementierungen
• Java: Einzelne ältere oder spezialisierte Serverprojekte

Die bekanntesten IRCDs sind heute UnrealIRCd und InspIRCd, weil sie flexibel, weit verbreitet und gut dokumentiert sind. Bahamut war lange Zeit der Server hinter DALnet. Ergo ist besonders interessant für neue Projekte, da es bereits Nickname- und Channel-Registrierung direkt integriert hat.

Mehr Informationen zu verschiedenen IRCDs, ihrer Einrichtung und ihren Unterschieden findest Du auf IRC-Mania.de/ircds.

Wichtige IRC-Channelmodes

Channelmodes sind Schalter für Kanäle, die bestimmen, wie Benutzer sich verhalten können. Sie werden mit dem Befehl MODE #kanal +... gesetzt. Die genauen Modi können zwischen IRCDs leicht variieren, die folgenden sind aber fast überall verbreitet:

• +t (Topic-Lock): Nur Channel-Operatoren dürfen das Topic ändern. Das verhindert, dass normale Benutzer das Topic verändern.
• +n (No External Messages): Benutzer außerhalb des Kanals können keine Nachrichten in den Kanal senden. So bleibt die Kommunikation auf die Mitglieder beschränkt.
• +m (Moderated): Nur Benutzer mit Status wie Operator oder Voice dürfen im Kanal schreiben. Alle anderen können nur lesen.
• +i (Invite-only): Der Kanal ist nur für eingeladene Benutzer sichtbar und beitretbar. Ein Beitritt erfordert einen INVITE.
• +k (Key): Der Kanal ist mit einem Passwort geschützt. Beitritt nur mit JOIN #kanal Passwort.
• +l (Limit): Begrenzt die maximale Anzahl an Benutzern im Kanal. Weitere Benutzer können erst beitreten, wenn wieder Platz ist.
• +s (Secret): Der Kanal ist geheim und erscheint nicht in öffentlichen Listen. WHOIS zeigt ihn ebenfalls nicht an.
• +p (Private): Der Kanal ist als privat markiert. Ähnlich wie +s, aber er erscheint noch in Listen mit unvollständigen Informationen.
• +b (Ban): Verhindert, dass bestimmte Benutzer dem Kanal beitreten. Bans arbeiten mit Masken wie *!*@host.
• +v (Voice): Gibt einem Benutzer das Recht, in einem moderierten Kanal (+m) zu sprechen. Im Chat wird der Benutzer durch ein + vor dem Namen gekennzeichnet.
• +o (Operator): Macht einen Benutzer zum Channel-Operator. Operatoren können Bans setzen, kicken, Themen ändern und Modi verwalten. Sie werden durch @ vor dem Namen gekennzeichnet.
• +r (Registered only): Nur registrierte und eingeloggte Benutzer dürfen dem Kanal beitreten.
• +c (No Colors): Verhindert farbige Formatierungen im Kanal, um Lesbarkeit und Übersicht zu wahren.
• +C (No CTCP): Blockiert CTCP-Anfragen an den Kanal, um Missbrauch wie CTCP-Flooding zu verhindern.
• +N (No Nickchanges): Benutzer im Kanal dürfen ihren Nickname nicht ändern, während sie im Kanal sind.
• +u (No Unregistered): Nur registrierte Benutzer dürfen im Kanal schreiben oder beitreten.
• +z (Op-only messages): Nachrichten von gebannten oder gemuteten Benutzern werden nur für Operatoren sichtbar.
• +O (Oper only): Nur Netzwerk-Operatoren dürfen dem Kanal beitreten.
• +M (Registered speak): Nur registrierte Benutzer dürfen im Kanal schreiben, unregistrierte Benutzer können aber beitreten und lesen.

Eine ausführliche Liste aller IRCD-Channelmodes mit Erklärungen findest Du auf IRC-Mania.de/alle-ircd-channelmodes-deutsch.

IRC-Services: Anope, Atheme und mehr

IRC-Services sind Dienste, die zusätzlich zum IRCD laufen und Funktionen bereitstellen, die der IRCD selbst nicht bietet. Die bekanntesten Services sind Nickname- und Channel-Registrierung, Authentifizierung und administrative Hilfsmittel.

Die wichtigsten IRC-Services-Pakete sind:

• Anope: Das verbreiteteste Services-Paket. Es bietet NickServ, ChanServ, HostServ, MemoServ und OperServ. Anope wird in C++ geschrieben und unterstützt viele IRCDs.
• Atheme: Ein alternatives, modernes Services-Paket, das besonders auf Sicherheit und Flexibilität setzt. Es enthält ebenfalls NickServ, ChanServ, HostServ und GroupServ.
• BitlBee: Ein spezieller Service, der IRC als Gateway zu anderen Chat-Protokollen wie XMPP, Matrix oder Mastodon nutzt. Man kann ihn auch als IRC-Bouncer verwenden.
• ChatServices: Ein älteres Services-Paket, das heute kaum noch neu eingesetzt wird.
• IRCServices: Ein weiteres historisches Paket, das als Grundlage für spätere Entwicklungen diente.

Typische Services-Accounts sind:

• NickServ: Verwaltet Nickname-Registrierungen und Anmeldungen.
• ChanServ: Verwaltet Channel-Registrierungen, Rechte, Modes und Themen.
• HostServ: Vergibt virtuelle Hosts oder Vhosts.
• MemoServ: Erlaubt das Hinterlassen von Nachrichten für andere Benutzer.
• OperServ: Administrative Werkzeuge für Netzwerk-Operatoren.

Eine Übersicht über aktuelle IRC-Services, ihre Einrichtung und Unterschiede findest Du auf IRC-Mania.de/ircservices.

Die wichtigsten IRC-Befehle

IRC wird über textbasierte Befehle gesteuert. Die wichtigsten Befehle, die Du als Benutzer, Entwickler oder Administrator kennen solltest, sind:

• /connect oder /server: Verbindet Dich mit einem IRC-Server.
• /nick: Ändert Deinen Nickname.
• /user: Sendet Benutzerinformationen beim Login, meist automatisch vom Client.
• /join: Tritt einem Kanal bei, zum Beispiel /join #kanal.
• /part: Verlässt einen Kanal, optional mit Grund /part #kanal Auf Wiedersehen.
• /quit: Beendet die Verbindung zum Server, optional mit Nachricht.
• /msg oder /privmsg: Sendet eine private Nachricht an einen Benutzer oder Kanal.
• /notice: Sendet eine Nachricht, die keine Antwort erwartet, oft für automatische Meldungen.
• /whois: Zeigt Informationen über einen Benutzer an.
• /whowas: Zeigt Informationen über einen kürzlich verwendeten Nickname an.
• /mode: Setzt Modi für Benutzer oder Kanäle, zum Beispiel /mode #kanal +o Nickname.
• /topic: Setzt oder zeigt das Topic eines Kanals an.
• /kick: Entfernt einen Benutzer aus einem Kanal, nur für Operatoren.
• /ban: Setzt einen Ban, meist über ChanServ oder /mode #kanal +b Maske.
• /invite: Lädt einen Benutzer in einen Invite-only-Kanal ein.
• /oper: Meldet Dich als Netzwerk-Operator an, erfordert konfigurierte Oper-Rechte.
• /ping und /pong: Halten die Verbindung aktiv und prüfen die Erreichbarkeit.
• /pass: Sendet ein Passwort beim Verbindungsaufbau, etwa für SASL oder Server-Passwörter.
• /away: Markiert Dich als abwesend mit einer Statusnachricht.
• /list: Zeigt eine Liste der öffentlichen Kanäle an.
• /names: Zeigt die Benutzer in einem Kanal an.
• /motd: Zeigt die Message of the Day des Servers an.
• /rules: Zeigt die Serverregeln an.
• /ns oder /nickserv: Interagiert mit NickServ, zum Beispiel für Registrierung oder Login.
• /cs oder /chanserv: Interagiert mit ChanServ, zum Beispiel für Channel-Registrierung und Rechteverwaltung.

Eine der ältesten und noch aktiv gepflegten deutschen IRC-Seiten mit einer ausführlichen Befehlsübersicht findest Du auf IRC-Mania.de/ircbefehle.

IRCv3, SASL und moderne Erweiterungen

IRC ist alles andere als tot. Mit IRCv3 gibt es einen Standardisierungsprozess, der das Protokoll für moderne Anforderungen fit macht. Wichtige IRCv3-Erweiterungen, die ein Nerd kennen sollte, sind:

• CAP (Capability Negotiation): Ermöglicht es Client und Server, vor dem Login auszuhandeln, welche Erweiterungen unterstützt werden. Ohne CAP gibt es kein SASL, keine extended-join und keine Batch-Nachrichten.
• SASL: Eine Authentifizierung während des Verbindungsaufbaus. Die gängigen Mechanismen sind PLAIN und EXTERNAL. EXTERNAL nutzt Client-Zertifikate und ist besonders sicher.
• away-notify: Der Server informiert den Client automatisch, wenn ein anderer Benutzer den Away-Status ändert. Das spart ständiges /whois.
• account-notify: Teilt mit, wenn sich ein Benutzer bei einem Service-Account ein- oder ausloggt.
• extended-join: Beim Betreten eines Kanals erhält der Client direkt Account-Name und Realname des Benutzers.
• multi-prefix: Ein Client sieht alle Status-Prefixe eines Benutzers, nicht nur das höchste. So wird etwa @+Nick statt nur @Nick übermittelt.
• batch: Mehrere zusammengehörige Nachrichten können als Batch gekennzeichnet werden, was besonders für Bridges und Clients nützlich ist.
• message-tags: Ermöglicht Metadaten an Nachrichten, etwa Reactions, Edit-Hinweise oder Custom-IDs.
• reply-client-tag: Erlaubt Threading-ähnliche Antworten auf Nachrichten, wie man sie von modernen Plattformen kennt.
• setname: Erlaubt es, den Realname während der Sitzung zu ändern, ohne sich neu zu verbinden.
• account-tag: Markiert Nachrichten mit dem Account-Namen des Absenders, was für Moderation und Scripts praktisch ist.

Wer ernsthaft mit IRC arbeitet, sollte sich mit CAP LS 302 verbinden und gezielt die Fähigkeiten aushandeln, die der Server anbietet.

Netzwerk-Topologie: Netsplits, U-Lines und Linking

Ein IRC-Netzwerk ist kein einzelner Server, sondern eine verteilte Struktur aus mehreren Servern, die untereinander verbunden sind. Das ist ein Kernunterschied zu zentralen Plattformen wie Discord oder Slack.

• Server-Link: Zwei IRCDs verbinden sich über einen verschlüsselten oder unverschlüsselten Link. Die Konfiguration dafür nennt man C:Lines, H:Lines oder Connect-Blöcke, je nach IRCD.
• U-Lines: Server, die als Services-Server gekennzeichnet sind, dürfen besondere Aktionen wie das Setzen von Modes ausführen. NickServ und ChanServ laufen typischerweise auf U-Lined-Servern.
• O-Lines: Bestimmen, wer Netzwerk-Operator ist. Oper-Rechte sind nichts für den Alltag, sondern für Serveradministration.
• Netsplit: Wenn die Verbindung zwischen zwei Servern abbricht, teilt sich das Netzwerk vorübergehend. Benutzer auf dem einen Teil verschwinden für den anderen Teil. Nach dem Wiederverbinden fluten die Server ihre Zustände und es kommt zum Netsplit-Join.
• Split Riding: Ein Angriff, bei dem jemand während eines Netsplits in einen Kanal eintritt und sich Operator-Rechte verschafft, bevor die Server wieder zusammenkommen. Gegenmaßnahmen sind TS (Timestamp) und diverse Schutzmechanismen der IRCDs.
• Services-Server: Ein spezieller Server oder ein Prozess, der über U-Lines eingebunden ist und Nickname-, Channel- und Admin-Services bereitstellt.

Für Admins ist das Verständnis von Linking, Netsplits und TS der Unterschied zwischen einem stabilen Netzwerk und einem Chaos-Server.

User- und Channel-Prefixe: Founder, Admin, Halfop, Voice

IRC-Kanäle haben eine Hierarchie, die über die klassischen @ und + hinausgeht. Moderne IRCDs und Services unterstützen mehrere Ebenen:

• ~ (Tilde): Founder. Der Besitzer eines registrierten Kanals, oft mit besonderen Rechten wie dem Setzen von ChanServ-Flags.
• & (Ampersand): Admin. Kann fast alles wie ein Operator, aber nicht andere Admins oder den Founder degradieren.
• @ (At): Operator. Kann kicken, bannen, Themen setzen und Modes ändern.
• % (Prozent): Halfop. Kann im Notfall sprechen, kicken und bei Bedarf kurzzeitig moderieren, hat aber weniger Rechte als ein Operator.
• + (Plus): Voice. Darf in einem moderierten Kanal (+m) sprechen und wird oft als vertrauenswürdiges Mitglied markiert.

Die entsprechenden Modes sind:

• +q für Founder
• +a für Admin
• +o für Operator
• +h für Halfop
• +v für Voice

Nicht jeder IRCD unterstützt alle diese Stufen. InspIRCd und UnrealIRCd kennen sie, kleinere IRCDs oder alte Netzwerke begnügen sich mit +o und +v.

IRC-Sicherheit für Nerds: Cloaks, CertFP und DNSBL

Wer einen Server oder einen wichtigen Bot betreibt, sollte über die Basics hinausgehen:

• Cloaking / Vhost: Eine Cloak versteckt die echte IP oder den Hostnamen eines Benutzers. Statt user@123-45-67-89.example.net sieht man etwa user@irc/member/MaxMustermann. Vhosts werden über HostServ oder den Server konfiguriert.
• CertFP: Certificate Fingerprint. Ein Client meldet sich mit einem TLS-Client-Zertifikat an. Der Server oder Services speichern den Fingerabdruck. So kann man sich ohne Passwort, aber dennoch sicher, authentifizieren.
• SASL EXTERNAL: Kombiniert SASL mit CertFP. Besonders sicher, weil kein Passwort übertragen wird.
• DNSBL: DNS-based Blackhole List. Server können IPs gegen bekannte Proxy- oder Spam-Listen prüfen und Verbindungen aus schwarzen Listen ablehnen.
• Open Proxy Scanner: Viele Netzwerke scannen eingehende Verbindungen auf offene Proxies, um Missbrauch zu verhindern.
• K-Line, G-Line, Z-Line, D-Line: Unterschiedliche Ban-Levels. K-Line bannt auf einem Server, G-Line netzwerkweit, Z-Line blockiert IP-Bereiche sofort auf Protokollebene, D-Line ist ein Doppelban oder netzwerkweiter DNS-Ban.
• Shun: Ein “stummer” Bann, bei dem der Benutzer noch verbunden ist, aber keine Nachrichten mehr senden kann. Nützlich für Störenfriede, die man beobachten will.
• ConnThrottle: Viele IRCDs haben Anti-Flood-Mechanismen, die zu viele Verbindungen pro Zeiteinheit von derselben IP blockieren.
• Secure-Only: Mit dem User-Mode +z oder Channel-Mode +z können Server so konfiguriert werden, dass nur TLS-verschlüsselte Benutzer teilnehmen dürfen.

DCC, CTCP und Filesharing über IRC

Neben dem normalen Textchat bietet IRC direkte Client-zu-Client-Verbindungen:

• CTCP (Client-to-Client Protocol): Spezielle Nachrichten, die von Clients ausgewertet werden, nicht vom Server. Beispiele sind CTCP VERSION, CTCP TIME, CTCP PING und CTCP ACTION. Letzteres wird für /me verwendet.
• DCC CHAT: Ein direkter Chat zwischen zwei Clients, ohne dass der Server die Nachrichten weiterleitet. Nützlich für verschlüsselte oder serverunabhängige Gespräche.
• DCC SEND: Ermöglicht den direkten Dateitransfer zwischen zwei Clients. Der Sender bietet die Datei an, der Empfänger bestätigt und baut eine direkte Verbindung auf.
• DCC RESUME: Erlaubt es, abgebrochene Übertragungen fortzusetzen. Wichtig bei größeren Dateien oder instabilen Verbindungen.
• DCC XMIT: Eine Erweiterung für verschlüsselte oder komprimierte Übertragungen, wird aber nur von wenigen Clients unterstützt.

DCC ist heute weniger verbreitet, weil NAT, Firewalls und TLS-Proxy es erschweren. Für gelegentliche Dateien oder direkte Chats ist es aber nach wie vor praktisch.

IRC-Scripting und Client-Erweiterungen

Viele IRC-Clients lassen sich erweitern und automatisieren. Für einen Nerd ist das eine der schönsten Seiten von IRC:

• mIRC Scripting: mIRC hat eine eigene Script-Sprache. Damit lassen sich Bots, automatisierte Antworten, Themes, Log-Tools und Spiele realisieren. Viele historische IRC-Scripts stammen aus der mIRC-Ära.
• Irssi Perl: Irssi unterstützt Perl-Scripts. Es gibt tausende Scripts für Logging, Benachrichtigungen, Spiele, Integrationen und Moderation.
• WeeChat Scripts: WeeChat bietet Scripting in Python, Perl, Ruby, Lua, Tcl und JavaScript. Besonders beliebt sind Buffer-Management, Matrix-Bridges und Erweiterungen für den täglichen Betrieb.
• ZNC-Module: ZNC selbst ist in C++ geschrieben und lässt sich mit Python-, Perl- oder C++-Modulen erweitern. Module können Loggen, Filter, Push-Benachrichtigungen oder externe Integrationen realisieren.
• The Lounge-Plugins: Über das Ökosystem von The Lounge lassen sich Themes und Erweiterungen integrieren, auch wenn das Plugin-System nicht so tief ist wie bei Irssi oder WeeChat.
• Eggdrop: Eggdrop ist ein klassischer IRC-Bot in C, der mit Tcl-Scripts erweitert wird. Er wird oft als Bouncer, Bot und Channel-Schutz gleichzeitig eingesetzt.

IRC vs. moderne Chat-Plattformen

IRC ist dezentral, textbasiert und offen. Das unterscheidet es grundlegend von modernen Plattformen:

• Discord: Zentralisiert, proprietär, mit Sprachchat, Bildschirmfreigabe und starken Moderationswerkzeugen. IRC ist leichter, offener und erfordert weniger Ressourcen.
• Matrix: Dezentral und föderiert, mit moderner End-to-End-Verschlüsselung und Rich-Media. Matrix ist komplexer, aber näher an modernen Anforderungen. IRC ist schlanker und hat weniger Overhead.
• Slack: Geschäftsorientiert, zentralisiert, mit vielen Integrationen. IRC ist kostenlos, offen und beliebt bei technischen Communities, die Wert auf Kontrolle legen.
• Telegram/Signal: Messenger mit zentraler oder föderierter Infrastruktur. Sie sind benutzerfreundlicher, aber nicht so offen wie IRC.
• Vorteile von IRC: Keine Registrierung zwingend, offene Protokolle, leichtgewichtig, skalierbar, viele Self-Hosting-Möglichkeiten, enorme historische Bedeutung.
• Nachteile von IRC: Keine native Bildschirmfreigabe, keine eingebaute History ohne Bouncer, oft steiler Einstieg für Anfänger, weniger moderne Features ohne IRCv3.

IRC-Kultur: Netsplits, Lurk und OP-Wars

IRC hat eine eigene Kultur, die über reine Technik hinausgeht:

• Lurking: Viele Benutzer sitzen stundenlang in Kanälen, ohne aktiv zu schreiben. Sie lesen mit, helfen gelegentlich und sind Teil der Community. Lurken ist völlig akzeptiert.
• Idling: Ähnlich wie Lurking, aber noch passiver. Ein gezieltes Idling kann mit Systemen wie FreeNode-Projekten oder Community-Kanälen verbunden sein, um Präsenz zu zeigen.
• Netsplits: Wer lange genug im IRC ist, erlebt sie. Ein Netsplit wird oft mit Memes wie “The Internet is broken” kommentiert.
• OP-Wars: Historisch gab es oft Konflikte um Operator-Rechte, besonders in unregistrierten Kanälen. Mit Services und Founder-Status sind solche Probleme heute seltener, aber nicht ausgestorben.
• ChanStats: Viele Netzwerke sammeln Statistiken über Aktivität, Worte, Zeilen und Zeiten. Das führt zu internen Ranglisten und Wettbewerben.
• IRC-Geschichte: IRC wurde 1988 von Jarkko Oikarinen entwickelt und ist damit älter als das World Wide Web. Es hat die frühe Internetkultur maßgeblich geprägt.
• Meme-Kultur: Viele Internet-Memes, wie “lol”, “afk”, “brb”, “asl” oder “rtfm”, haben ihre Wurzeln im IRC.

IRC-Bot-Architektur: Event-Loop, Parser und Plugins

Ein guter IRC-Bot ist mehr als ein einfaches Socket-Script. Die Architektur besteht aus mehreren Schichten:

• Verbindungsschicht: Verantwortlich für TCP-Verbindung, TLS-Handshake, PING/PONG und Reconnect. Sie sollte Verbindungsabbrüche sauber behandeln.
• Parser: Wandelt eingehende IRC-Nachrichten in interne Events um. Ein typisches Format ist :nick!user@host COMMAND target :message. Der Parser muss Prefix, Command, Parameter und Trailer trennen.
• Event-Loop: Verteilt eingehende Events an Handler. Beispiele sind on_message, on_join, on_part, on_nick_change, on_kick und on_disconnect.
• Command-Router: Ordnet Benutzerbefehle wie !help oder !weather passenden Funktionen zu. Oft mit Prefix und Berechtigungsprüfung.
• Plugin-System: Lädt externe Module zur Laufzeit. Plugins sollten isoliert sein und über eine klare API mit dem Bot kommunizieren.
• Datenbank-Layer: Speichert Konfiguration, Logs, Benutzerdaten oder Channel-Statistiken. SQLite reicht für kleine Bots, PostgreSQL für größere Setups.
• Rate-Limiter: Verhindert, dass der Bot zu viele Nachrichten sendet und vom Server gefloodet wird. Oft mit Token-Bucket-Algorithmus.
• Permission-System: Prüft, ob ein Benutzer bestimmte Befehle ausführen darf. Kanäle, Oper-Status oder Nickname-Registrierung können als Kriterien dienen.

Wer einen eigenen Bot ernsthaft betreiben will, sollte nicht alles selbst bauen, sondern ein etabliertes Framework als Basis nutzen und darauf eigene Plugins entwickeln.

Selbst einen IRCD aufsetzen: Die ersten Schritte

Für echte Nerds ist das Aufsetzen eines eigenen IRC-Servers ein Rite of Passage. Die typischen Schritte sind:

1. IRCD wählen: Anfänger starten oft mit UnrealIRCd oder InspIRCd, weil es viele Tutorials gibt. Ergo ist eine gute Wahl, wenn man integrierte Services möchte.
2. Server installieren: Entweder über Paketmanager, Docker-Image oder manuelles Kompilieren aus dem Source-Code.
3. Konfiguration anpassen: Die Hauptkonfiguration enthält Server-Name, Admin-Info, Listen-Ports, TLS-Zertifikate, Oper-Lines und Link-Blöcke.
4. Services einbinden: Für Nickname- und Channel-Registrierung installiert man Anope oder Atheme und verbindet sie über U-Lines.
5. Bouncer ergänzen: ZNC oder The Lounge ermöglicht es, dauerhaft verbunden zu bleiben und von mehreren Geräten zu chatten.
6. Firewall und DNS: Ports 6667 und 6697 öffnen, DNS-Einträge für irc.deinedomain.de setzen und optional Reverse-DNS konfigurieren.
7. Testen und Öffnen: Zuerst lokal testen, dann Freunden Zugang geben, dann eventuell öffentlich machen. Dabei immer Serverregeln und Anti-Spam-Maßnahmen beachten.
8. Monitoring: Logs rotieren, Verbindungen überwachen, regelmäßig Updates des IRCDs und der Services einspielen.

Ein eigener IRCD ist ideal für kleine Communities, Lernzwecke oder als abgeschotteter Kommunikationsraum für Teams.

Hall of Fame: Menschen, die IRC geprägt haben und mich begeistert.

IRC ist kein anonymes Protokoll, sondern das Ergebnis von Jahrzehnten Arbeit einzelner Menschen. Dieser Abschnitt ist ein kleiner Tribut an Developer, Admins und Visionäre, die das IRC-Ökosystem maßgeblich geformt haben. IRC habe ich in sehr jungen Jahren kennengelernt, teilweise nur um Bilder oder Files zu traden, aber mich haben damals schon die Entwickler begeistert, die so große Projekte gestämmt haben. Codemastr, Andrew Cheuch usw.
Hier meine Favoriten:

• Jarkko Oikarinen: Der Erfinder von IRC. 1988 entwickelte er die erste Version am Finnischen Zentrum für Wissenschaftliche Rechnung. Ohne ihn gäbe es keinen IRC, kein mIRC, keinen ZNC und keine der Communities, die wir heute kennen.
• Andrew Church: Verantwortlich für IRCServices, eines der frühesten und einflussreichsten IRC-Services-Pakete. Seine Arbeit legte den Grundstein für Nickname- und Channel-Registrierung, wie wir sie heute von NickServ und ChanServ kennen.
• Carsten V. Munk (stskeeps): Lange Zeit eine zentrale Figur bei UnrealIRCd. Er trieb Features, Netzwerklogik und die Modularität voran, die UnrealIRCd zu einem der bekanntesten IRCDs machten.
• codemastr: Einer der langjährigen Hauptentwickler von UnrealIRCd. Er war maßgeblich an der Stabilisierung und Erweiterung des Codes beteiligt und prägte die Architektur, auf der viele Server noch heute laufen.
• Darren Reed: Entwickler von ircd und später DALnets Bahamut. Seine Arbeit beeinflusste die Server-Seite des IRCs in den 1990er Jahren stark.
• Roger Espel Llima: Schuf EPIC, einen der ältesten und flexibelsten IRC-Clients. EPIC war Vorreiter für viele Features, die später in anderen Clients auftauchten.
• Khaled Mardam-Bey: Entwickler von mIRC, dem Windows-Client, der Millionen Benutzern in den 1990ern und 2000ern den IRC näherbrachte. mIRC Scripting prägte eine ganze Generation von IRC-Bots und -Scripts.
• Timo Sirainen: Entwickler von Irssi und später auch von Dovecot. Irssi ist nach wie vor einer der beliebtesten Terminal-IRC-Clients für Nerds und Serveradmins.
• Sébastien Helleu (FlashCode): Initiator und Hauptentwickler von WeeChat. Er baute einen der modernsten und erweiterbarsten Terminal-Clients.
• Robey Pointer: ursprünglicher Autor von Eggdrop, dem klassischen IRC-Bot in C mit Tcl-Scripting. Eggdrop war lange Zeit der Standard für Channel-Schutz und Automation.
• Das Anope-Team: Viele Maintainer über die Jahre haben aus Anope das verbreitetste Services-Paket gemacht. Es verbindet heute fast jeden IRCD mit einer verlässlichen Registrierungsinfrastruktur.
• Das Atheme-Team: Mit Entwicklern wie nenolod und jilles hat Atheme eine Alternative zu Anope geschaffen, die besonders auf Sicherheit und moderne Features setzt.
• Daniel Oaks und das Ergo-Team: Daniel Oaks trieb IRCv3 und das moderne IRCD Ergo (ehemals Oragono) voran. Ergo zeigt, dass IRC auch im Jahr 2026 noch weiterentwickelt werden kann.
• Das ZNC-Team: Maintainer und Mitwirkende wie psychon und prozac haben ZNC zum Standard-IRC-Bouncer gemacht.
• Wilmer van der Gaast: Initiator von BitlBee, der IRC-Brücke zu anderen Chat-Protokollen. BitlBee beweist, dass IRC als zentrale Schnittstelle für alle Kommunikation dienen kann.
• Das The-Lounge-Team: Moderne Web-Entwickler, die mit The Lounge bewiesen haben, dass IRC im Browser zeitgemäß und benutzerfreundlich sein kann.

Auch Moxquiz darf in einer Hall of Fame nicht fehlen: der deutsche IRC-Quiz-Bot, der in vielen Kanälen für spannende Trivia-Runden und interne Wettkämpfe gesorgt hat. Er zeigt, dass IRC-Bots nicht nur für Administration oder Filesharing genutzt werden, sondern auch als Unterhaltung und Gemeinschaftserlebnis funktionieren.

Diese Liste ist natürlich unvollständig. Hinter jedem IRCD, jedem Client und jedem Service stehen Dutzende oder Hunderte von Mitwirkenden, die über Jahre hinweg Bugfixes, Dokumentation, Support und Ideen beigesteuert haben. Wer heute IRC nutzt, steht auf den Schultern dieser Community.

Was Du bei der Programmierung mit IRC beachten solltest

Wenn Du eigene IRC‑Clients oder Bots programmierst, gibt es einige Details, die schnell übersehen werden, aber für einen stabilen Betrieb wichtig sind:

• PING/PONG: IRC‑Server senden regelmäßig PING-Anfragen. Antwortest Du nicht mit PONG, trennt der Server die Verbindung. Eine einfache PING/PONG-Behandlung ist daher Pflicht.
• Nachrichtenlänge: Eine IRC-Nachricht darf inklusive \r\n maximal 512 Bytes lang sein. Längere Nachrichten müssen aufgeteilt werden.
• Ratenlimits: Zu viele Nachrichten in kurzer Zeit führen zu einem temporären Ausschluss (Excess Flood). Baue Pausen ein, besonders bei automatisierten Nachrichten.
• Encoding: Die meisten modernen Netzwerke verwenden UTF‑8. Achte darauf, dass Ein- und Ausgabe konsistent kodiert sind.
• TLS bevorzugen: Nutze für den Produktiveinsatz möglichst Port 6697 mit TLS/SSL, um Verbindung und Zugangsdaten zu schützen.
• Fehlerbehandlung: Netzwerkverbindungen können abbrechen. Eine Reconnect‑Logik und saubere Fehlerbehandlung machen Deinen Bot robust.
• Serverregeln beachten: Jedes IRC-Netzwerk hat eigene Regeln für Bots, Nicknames und Kanäle. Halte Dich an diese, um nicht gekickt oder gebannt zu werden.
• Keine Secrets im Code: Passwörter, API‑Keys oder Zugangsdaten für Nickname‑Services gehören nie in den Quellcode, sondern in Umgebungsvariablen oder ein separates Konfigurationsmanagement.

Weitere Tutorials, Server‑Listen und Tipps rund um IRC findest Du auf IRC-Mania.de. Für Fragen zum Protokoll, zu Befehlen und zum Verhalten von Servern lohnt sich auch ein Blick auf IRC-FAQ.de.

FAQ: IRC, Coding und Sicherheit (Internet Relay Chat)

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert