writeSlow("My name, as you can tell, is hacker101.");
writeSlow("And yours must be... don't say it... it's "+SaveSystem.CurrentSave.Username+"@"+SaveSystem.CurrentSave.SystemName+", right?");
writeSlow("Of course it is.");
writeSlow("And I bet you 10,000 Codepoints that you have... "+SaveSystem.CurrentSave.Codepoints.ToString()+" Codepoints.");
writeSlow("Oh, and how much upgrades have you installed since you first started using ShiftOS?");
writeSlow("That would be... uhh... "+SaveSystem.CurrentSave.CountUpgrades().ToString()+".");
writeSlow("I'm probably freaking you out right now. You are probably thinking that you're unsafe and need to lock yourself down.");
writeSlow("But, don't worry, I mean no harm.");
writeSlow("In fact, I am a multi-user domain safety activist and security professional.");
writeSlow("I need your help with something.");
writeSlow("Inside the multi-user domain, every now and then these 'dead' user accounts pop up.");
writeSlow("They're infesting everything. They're in every legion, they infest chatrooms, and they take up precious hard drive space.");
writeSlow("Eventually there's going to be tons of them just sitting there taking over the MUD. We can't have that.");
writeSlow("It sounds like a conspiracy theory indeed, but it's true, in fact, these dead accounts hold some valuable treasures.");
writeSlow("I'm talking Codepoints, skins, documents, the possibilities are endless.");
writeSlow("I'm going to execute a quick sys-script that will show you how you can help get rid of these accounts, and also gain some valuable resources to help you on your digital frontier.");
writeSlow("This script will also show you the fundamentals of security exploitation and theft of resources - which if you want to survive in the multi-user domain is paramount.");
tut.SetObjective("Welcome to the dead account exploitation tutorial. In this tutorial you will learn the basics of hacking within the multi-user domain.");
Thread.Sleep(1000);
tut.SetObjective("We will start with a simple system exploit - gaining kernel-level access to ShiftOS. This can help you perform actions not ever possible in the user level.");
Thread.Sleep(1000);
tut.SetObjective("To gain root access, you will first need to breach the system watchdog to keep it from dialing home to DevX.");
Thread.Sleep(1000);
tut.SetObjective("The watchdog can only function when it has a successful connection to the multi-user domain. You will need to use the MUD Control Centre to disconnect yourself from the MUD. This will lock you out of most features. To disconnect from the multi-user domain, simply run the 'mud.disconnect' command.");
while(tutPos==0)
{
}
tut.SetObjective("As you can see, the kernel watchdog has shut down temporarily, however before the disconnect it was able to tell DevX that it has gone offline.");
Thread.Sleep(1000);
tut.SetObjective("You'll also notice that commands like the shiftorium, MUD control centre and various applications that utilize these system components no longer function.");
Thread.Sleep(1000);
tut.SetObjective("The watchdog, however, is still watching. DevX was smart and programmed the kernel to log all events to a local file in 0:/system/data/kernel.log.");
Thread.Sleep(1000);
tut.SetObjective("You will need to empty out this file before you can connect to the multi-user domain, as the watchdog will send the contents of this file straight to DevX.");
Thread.Sleep(1000);
tut.SetObjective("Or, you can do what we're about to do and attempt to decrypt the log and sniff out the kernel-mode access password.");
Thread.Sleep(1000);
tut.SetObjective("This will allow us to gain kernel-level access to our system using the krnl.control{pass:} command.");
Thread.Sleep(1000);
tut.SetObjective("Let's start decrypting the log file using the hacker101.brute_decrypt{file:} script. The file: argument is a string and should point to a .log file. When the script succeeds, you will see a TextPad open with the decrypted contents.");
while(tutPos==1)
{
}
onCompleteDecrypt+=ondec;
tut.SetObjective("This script isn't the most agile script ever, but it'll get the job done.");
tut.SetObjective("Alright - it's done. Here's how it's laid out. In each log entry, you have the timestamp, then the event name, then the event description.");
Thread.Sleep(1000);
tut.SetObjective("Look for the most recent 'mudhandshake' event. This contains the kernel access code.");
Thread.Sleep(1000);
tut.SetObjective("Once you have it, run 'krnl.control{pass:\"the-kernel-code-here\"}. This will allow you to gain access to the kernel.");
while(tutPos==3)
{
}
tut.SetObjective("You are now in kernel mode. Every command you enter will run on the kernel. Now, let's clear the watchdog's logfile and reconnect to the multi-user domain.");
Thread.Sleep(1000);
tut.SetObjective("To clear the log, simply run 'puppy.clear'.");
while(tutPos==4)
{
}
tut.SetObjective("Who's a good dog... You are, ShiftOS. Now, we can connect back to the MUD using 'mud.reconnect'.");
Thread.Sleep(1000);
while(tutPos==5)
{
}
tut.SetObjective("We have now snuck by the watchdog and DevX has no idea. With kernel-level access, everything you do is not logged, however if you perform too much in one shot, you'll get kicked off and locked out of the multi-user domain temporarily.");
Thread.Sleep(1000);
tut.SetObjective("So, let's focus on the job. You want to get into one of those fancy dead accounts, don't ya? Well, first, we need to talk with the MUD to get a list of these accounts.");
Thread.Sleep(1000);
tut.SetObjective("Simply run the `mud.sendmsg` command, specifying a 'header' of \"getusers\", and a body of \"dead\".");
while(tutPos==6)
{
}
tut.SetObjective("Great. We now have the usernames and sysnames of all dead accounts on the MUD. Now let's use the hacker101.breach_user_password{user:,sys:} command to breach one of these accounts' passwords.");
while(tutPos==7)
{
}
tut.SetObjective("There - you now have access to that account. Use its password, username and sysname and run the hacker101.print_user_info{user:,pass:,sys:} command to print the entirety of this user's information.");
while(tutPos==8)
{
}
tut.SetObjective("Now you can see a list of the user's Codepoints among other things. Now you can steal their codepoints by using the hacker101.steal_codepoints{user:,pass:,sys;,amount:} command. Be careful. This may alert DevX.");
while(tutPos==9)
{
}
if(devx_alerted==true)
{
tut.SetObjective("Alright... enough fun and games. DevX just found out we were doing this.");
Thread.Sleep(500);
tut.SetObjective("Quick! Disconnect from the MUD!!");
while(tutPos==10)
{
}
tut.SetObjective("Now, get out of kernel mode! To do that, run krnl.lock_session.");
while(tutPos==11)
{
}
}
else
{
tut.SetObjective("OK, that was risky, but we pulled it off. Treat yourself! But first, let's get you out of kernel mode.");
Thread.Sleep(500);
tut.SetObjective("First we need to get you off the MUD. Simply run mud.disconnect again.");
while(tutPos==10)
{
}
tut.SetObjective("Now, let's run krnl.lock_session. This will lock you back into the user mode, and reconnect you to the MUD.");
while(tutPos==11)
{
}
tut.SetObjective("If, for some reason, DevX DOES find out, you have to be QUICK to get off of kernel mode. You don't want to make him mad.");
}
Thread.Sleep(1000);
tut.SetObjective("So that's all for now. Whenever you're in kernel mode again, and you have access to a user account, try breaching their filesystem next time. You can use sos.help{ns:} to show commands from a specific namespace to help you find more commands easily.");
Thread.Sleep(1000);
tut.SetObjective("You can now close this window.");
