mirror of
https://github.com/seriocomedy/ShiftOS-C-.git
synced 2025-01-22 10:50:27 -05:00
625 lines
23 KiB
C#
625 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.IO.Compression;
|
|
using System.Linq;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
|
|
namespace ShiftOS
|
|
{
|
|
class Viruses
|
|
{
|
|
public static Dictionary<string, string> Infections = new Dictionary<string, string>();
|
|
|
|
public static void CheckForInfected()
|
|
{
|
|
VirusTimer.Interval = 1000;
|
|
Infections.Clear();
|
|
Scan(Paths.SaveRoot);
|
|
VirusTimer.Tick += new EventHandler(VirusTimer_Tick);
|
|
VirusTimer.Start();
|
|
}
|
|
|
|
public static void VirusTimer_Tick(object sender, EventArgs e)
|
|
{
|
|
ShiftoriumKiller.KillRandomUpgrade();
|
|
if(InfectedWith("beepseverysecond"))
|
|
{
|
|
API.PlaySound(Properties.Resources._3beepvirus);
|
|
}
|
|
if(InfectedWith("imtheshifternow"))
|
|
{
|
|
Skinning.Utilities.Randomize();
|
|
}
|
|
}
|
|
|
|
public static void Scan(string directory)
|
|
{
|
|
foreach(string file in Directory.GetFiles(directory))
|
|
{
|
|
CheckInfected(file);
|
|
}
|
|
foreach(string dir in Directory.GetDirectories(directory))
|
|
{
|
|
if(dir != Paths.Mod_Temp) {
|
|
Scan(dir);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void ScanForInfectable(string directory, ref List<string> file_list)
|
|
{
|
|
foreach (string file in Directory.GetFiles(directory))
|
|
{
|
|
var finf = new FileInfo(file);
|
|
switch (finf.Extension) {
|
|
case ".skn":
|
|
case ".spk":
|
|
case ".dri":
|
|
case ".stp":
|
|
case ".pkg":
|
|
if (finf.Name != "HDD.dri")
|
|
{
|
|
file_list.Add(file);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
foreach (string dir in Directory.GetDirectories(directory))
|
|
{
|
|
if (dir != Paths.Mod_Temp)
|
|
{
|
|
ScanForInfectable(dir, ref file_list);
|
|
}
|
|
}
|
|
}
|
|
const string virusfilename = "00110";
|
|
|
|
|
|
public static void CheckInfected(string filepath) {
|
|
var finf = new FileInfo(filepath);
|
|
switch(finf.Extension)
|
|
{
|
|
case ".stp":
|
|
case ".spk":
|
|
case ".pkg":
|
|
case ".skn":
|
|
if (File.Exists(finf.FullName))
|
|
{
|
|
try {
|
|
string pth = Paths.SystemDir + "_virusregister";
|
|
API.ExtractFile(finf.FullName, pth, false);
|
|
string dirsep = "\\";
|
|
switch (OSInfo.GetPlatformID())
|
|
{
|
|
case "microsoft":
|
|
dirsep = "\\";
|
|
break;
|
|
default:
|
|
dirsep = "/";
|
|
break;
|
|
}
|
|
if (File.Exists(pth + dirsep + virusfilename))
|
|
{
|
|
string encrypted = File.ReadAllText(pth + dirsep + virusfilename);
|
|
if (encrypted != "" && encrypted != null)
|
|
{
|
|
foreach (string line in API.Encryption.Decrypt(encrypted).Split(';'))
|
|
{
|
|
if (Infections.ContainsKey(line))
|
|
{
|
|
Infections[line] += ";" + finf.FullName;
|
|
}
|
|
else {
|
|
Infections.Add(line, finf.FullName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Directory.Delete(pth, true);
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
API.LogException("Corrupted package file detected while checking for infections... skipping.", false);
|
|
}
|
|
}
|
|
break;
|
|
case ".dri":
|
|
if (finf.Name != "HDD.dri" && !finf.Name.Contains("BN") && finf.Name != "Network.dri")
|
|
{
|
|
if (File.ReadAllText(finf.FullName) != "")
|
|
{
|
|
string encrypted = File.ReadAllText(finf.FullName);
|
|
try
|
|
{
|
|
foreach (string line in API.Encryption.Decrypt(encrypted).Split(';'))
|
|
{
|
|
if (Infections.ContainsKey(line))
|
|
{
|
|
Infections[line] += ";" + finf.FullName;
|
|
}
|
|
else {
|
|
Infections.Add(line, finf.FullName);
|
|
}
|
|
}
|
|
}
|
|
catch (CryptographicException cex)
|
|
{
|
|
if (encrypted != "")
|
|
{
|
|
string decrypted = API.Encryption.Decrypt(encrypted);
|
|
if (Infections.ContainsKey(decrypted))
|
|
{
|
|
Infections[decrypted] += ";" + finf.FullName;
|
|
}
|
|
else {
|
|
Infections.Add(decrypted, finf.FullName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
public enum VirusID
|
|
{
|
|
ShiftoriumKiller,
|
|
WindowsEverywhere,
|
|
WindowMicrofier,
|
|
Bye,
|
|
WindowSpazzer,
|
|
KeyboardFucker,
|
|
ImTheShifterNow,
|
|
ThanksfortheInfo,
|
|
SkinInterceptor,
|
|
HolyFuckMyEars,
|
|
BeepsEverySecond,
|
|
MouseTrap,
|
|
Seized,
|
|
FileFucker,
|
|
}
|
|
|
|
public class FileFucker
|
|
{
|
|
public static void GetSomeFiles(string directory, ref List<string> file_list)
|
|
{
|
|
foreach (string file in Directory.GetFiles(directory))
|
|
{
|
|
var finf = new FileInfo(file);
|
|
switch (finf.Extension)
|
|
{
|
|
case ".npk":
|
|
case ".docx":
|
|
case ".doc":
|
|
case ".owd":
|
|
case ".txt":
|
|
if (finf.Name != "names.npk" && finf.Name != "_Log.txt")
|
|
{
|
|
file_list.Add(file);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
foreach (string dir in Directory.GetDirectories(directory))
|
|
{
|
|
if (dir != Paths.Mod_Temp)
|
|
{
|
|
GetSomeFiles(dir, ref file_list);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void Infect()
|
|
{
|
|
List<string> files = new List<string>();
|
|
GetSomeFiles(Paths.SaveRoot, ref files);
|
|
var rnd = new Random();
|
|
string fname = files[rnd.Next(0, files.Count - 1)];
|
|
string fcontents = File.ReadAllText(fname);
|
|
string encrypted = API.Encryption.Encrypt(fcontents);
|
|
File.WriteAllText(fname, encrypted);
|
|
}
|
|
}
|
|
|
|
public static bool InfectedWith(string id)
|
|
{
|
|
if(Infections.ContainsKey("virus:" + id))
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static void InfectFile(string FileName, VirusID id)
|
|
{
|
|
bool cont = false;
|
|
string infectionString = "virus:";
|
|
switch (id)
|
|
{
|
|
case VirusID.WindowSpazzer:
|
|
infectionString = "virus:windowspazzer";
|
|
break;
|
|
case VirusID.WindowMicrofier:
|
|
infectionString = "virus:windowmicrofier";
|
|
break;
|
|
case VirusID.Bye:
|
|
infectionString = "virus:bye";
|
|
break;
|
|
case VirusID.ShiftoriumKiller:
|
|
infectionString = "virus:shiftoriumkiller";
|
|
break;
|
|
case VirusID.WindowsEverywhere:
|
|
infectionString = "virus:windowseverywhere";
|
|
break;
|
|
case VirusID.KeyboardFucker:
|
|
infectionString = "virus:keyboardfucker";
|
|
break;
|
|
case VirusID.ImTheShifterNow:
|
|
infectionString = "virus:imtheshifternow";
|
|
break;
|
|
case VirusID.ThanksfortheInfo:
|
|
infectionString = "virus:thanksfortheinfo";
|
|
break;
|
|
case VirusID.SkinInterceptor:
|
|
infectionString = "virus:skininterceptor";
|
|
break;
|
|
case VirusID.HolyFuckMyEars:
|
|
infectionString = "virus:holyfuckmyears";
|
|
break;
|
|
case VirusID.BeepsEverySecond:
|
|
infectionString = "virus:beepseverysecond";
|
|
break;
|
|
case VirusID.Seized:
|
|
infectionString = "virus:seized";
|
|
break;
|
|
case VirusID.FileFucker:
|
|
infectionString = "virus:filefucker";
|
|
break;
|
|
}
|
|
FileInfo finf = new FileInfo(FileName);
|
|
switch(finf.Extension)
|
|
{
|
|
case ".skn":
|
|
case ".spk":
|
|
case ".stp":
|
|
case ".pkg":
|
|
if(!Directory.Exists(Paths.Mod_Temp))
|
|
{
|
|
Directory.CreateDirectory(Paths.Mod_Temp);
|
|
}
|
|
string pth = Paths.SystemDir + "_virusinfect1";
|
|
API.ExtractFile(finf.FullName, pth, false);
|
|
string dirsep = "\\";
|
|
switch (OSInfo.GetPlatformID())
|
|
{
|
|
case "microsoft":
|
|
dirsep = "\\";
|
|
break;
|
|
default:
|
|
dirsep = "/";
|
|
break;
|
|
}
|
|
InfectFile(pth + dirsep + virusfilename, id);
|
|
File.Delete(finf.FullName);
|
|
ZipFile.CreateFromDirectory(pth, FileName);
|
|
Directory.Delete(pth, true);
|
|
break;
|
|
case ".dri":
|
|
if(finf.Name == "HDD.dri" || finf.Name.Contains("BN") || finf.Name == "Network.dri")
|
|
{
|
|
throw new NotHappeningException("You're not going to attempt to infect that file, are you?");
|
|
}
|
|
else
|
|
{
|
|
try {
|
|
string encryptedfile = File.ReadAllText(finf.FullName);
|
|
string unencryptedfile = API.Encryption.Decrypt(encryptedfile);
|
|
unencryptedfile += ";" + infectionString;
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(unencryptedfile));
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(infectionString));
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
cont = true;
|
|
break;
|
|
|
|
}
|
|
if (cont == true)
|
|
{
|
|
if (finf.Name == virusfilename)
|
|
{
|
|
try
|
|
{
|
|
string encryptedfile = File.ReadAllText(finf.FullName);
|
|
string unencryptedfile = API.Encryption.Decrypt(encryptedfile);
|
|
unencryptedfile += ";" + infectionString;
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(unencryptedfile));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(infectionString));
|
|
}
|
|
}
|
|
}
|
|
CheckForInfected();
|
|
}
|
|
|
|
public static void DisInfect(string FileName)
|
|
{
|
|
bool cont = false;
|
|
FileInfo finf = new FileInfo(FileName);
|
|
switch (finf.Extension)
|
|
{
|
|
case ".skn":
|
|
case ".spk":
|
|
case ".stp":
|
|
case ".pkg":
|
|
string pth = Paths.SystemDir + "_viruscheck";
|
|
API.ExtractFile(finf.FullName, pth, false);
|
|
string dirsep = "\\";
|
|
switch (OSInfo.GetPlatformID())
|
|
{
|
|
case "microsoft":
|
|
dirsep = "\\";
|
|
break;
|
|
default:
|
|
dirsep = "/";
|
|
break;
|
|
}
|
|
if(File.Exists(pth + dirsep + virusfilename))
|
|
{
|
|
File.Delete(pth + dirsep + virusfilename);
|
|
}
|
|
File.Delete(finf.FullName);
|
|
ZipFile.CreateFromDirectory(pth, finf.FullName);
|
|
Directory.Delete(pth, true);
|
|
break;
|
|
case ".dri":
|
|
if (finf.Name == "HDD.dri" || finf.Name.Contains("BN") || finf.Name == "Network.dri")
|
|
{
|
|
throw new NotHappeningException("You're not going to attempt to infect that file, are you?");
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
string encryptedfile = File.ReadAllText(finf.FullName);
|
|
string unencryptedfile = API.Encryption.Decrypt(encryptedfile);
|
|
unencryptedfile = "";
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(unencryptedfile));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
File.WriteAllText(finf.FullName, "");
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
cont = true;
|
|
break;
|
|
|
|
}
|
|
CheckForInfected();
|
|
}
|
|
|
|
public static void InfectFile(string FileName, string id)
|
|
{
|
|
bool cont = false;
|
|
string infectionString = "virus:" + id;
|
|
FileInfo finf = new FileInfo(FileName);
|
|
switch (finf.Extension)
|
|
{
|
|
case ".skn":
|
|
case ".spk":
|
|
case ".stp":
|
|
case ".pkg":
|
|
string pth = Paths.SystemDir + "_virusinfect2";
|
|
API.ExtractFile(finf.FullName, pth, false);
|
|
string dirsep = "\\";
|
|
switch (OSInfo.GetPlatformID())
|
|
{
|
|
case "microsoft":
|
|
dirsep = "\\";
|
|
break;
|
|
default:
|
|
dirsep = "/";
|
|
break;
|
|
}
|
|
InfectFile(pth + dirsep + virusfilename, id);
|
|
File.Delete(finf.FullName);
|
|
ZipFile.CreateFromDirectory(pth, finf.FullName);
|
|
Directory.Delete(pth, true);
|
|
break;
|
|
case ".dri":
|
|
if (finf.Name == "HDD.dri" || finf.Name.Contains("BN") || finf.Name == "Network.dri")
|
|
{
|
|
throw new NotHappeningException("You're not going to attempt to infect that file, are you?");
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
string encryptedfile = File.ReadAllText(finf.FullName);
|
|
string unencryptedfile = API.Encryption.Decrypt(encryptedfile);
|
|
unencryptedfile += ";" + infectionString;
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(unencryptedfile));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(infectionString));
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
cont = true;
|
|
break;
|
|
|
|
}
|
|
if (cont == true)
|
|
{
|
|
if (finf.Name == virusfilename)
|
|
{
|
|
try
|
|
{
|
|
string encryptedfile = File.ReadAllText(finf.FullName);
|
|
string unencryptedfile = API.Encryption.Decrypt(encryptedfile);
|
|
unencryptedfile += ";" + infectionString;
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(unencryptedfile));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
File.WriteAllText(finf.FullName, API.Encryption.Encrypt(infectionString));
|
|
}
|
|
}
|
|
}
|
|
CheckForInfected();
|
|
}
|
|
|
|
|
|
public static void InfectRandom()
|
|
{
|
|
var rnd = new Random();
|
|
var files = new List<string>();
|
|
ScanForInfectable(Paths.SaveRoot, ref files);
|
|
string filetoinfect = files[rnd.Next(0, files.Count - 1)];
|
|
VirusID v = VirusID.ShiftoriumKiller;
|
|
int vid = rnd.Next(0, 11);
|
|
switch(vid)
|
|
{
|
|
case 0:
|
|
v = VirusID.ShiftoriumKiller;
|
|
break;
|
|
case 1:
|
|
v = VirusID.WindowsEverywhere;
|
|
break;
|
|
case 2:
|
|
v = VirusID.ImTheShifterNow;
|
|
break;
|
|
case 3:
|
|
v = VirusID.BeepsEverySecond;
|
|
break;
|
|
case 4:
|
|
v = VirusID.FileFucker;
|
|
break;
|
|
case 5:
|
|
v = VirusID.MouseTrap;
|
|
break;
|
|
case 6:
|
|
v = VirusID.Seized;
|
|
break;
|
|
case 7:
|
|
v = VirusID.SkinInterceptor;
|
|
break;
|
|
case 8:
|
|
v = VirusID.ThanksfortheInfo;
|
|
break;
|
|
case 9:
|
|
v = VirusID.KeyboardFucker;
|
|
break;
|
|
case 10:
|
|
v = VirusID.WindowMicrofier;
|
|
break;
|
|
case 11:
|
|
v = VirusID.Bye;
|
|
break;
|
|
case 12:
|
|
v = VirusID.WindowSpazzer;
|
|
break;
|
|
}
|
|
InfectFile(filetoinfect, v);
|
|
}
|
|
|
|
public static void DropDevXPayload()
|
|
{
|
|
//Viruses...
|
|
var files = new List<string>();
|
|
ScanForInfectable(Paths.SaveRoot, ref files);
|
|
try {
|
|
var rnd = new Random();
|
|
string file = files[rnd.Next(0, files.Count - 1)];
|
|
InfectFile(file, VirusID.ImTheShifterNow);
|
|
InfectFile(file, VirusID.MouseTrap);
|
|
}
|
|
catch(NotHappeningException nhex)
|
|
{
|
|
DropDevXPayload();
|
|
}
|
|
|
|
}
|
|
|
|
private static Timer VirusTimer = new Timer();
|
|
|
|
public class ShiftoriumKiller
|
|
{
|
|
public static void KillRandomUpgrade()
|
|
{
|
|
if(Viruses.InfectedWith("shiftoriumkiller"))
|
|
{
|
|
int id = new Random().Next(0, SaveSystem.ShiftoriumRegistry.DefaultUpgrades.Count - 1);
|
|
Shiftorium.Upgrade upg = SaveSystem.ShiftoriumRegistry.DefaultUpgrades[id];
|
|
int chance = new Random().Next(0, 100);
|
|
if(chance == 50)
|
|
{
|
|
Shiftorium.Utilities.Unbuy(upg.id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class KeyboardInceptor
|
|
{
|
|
public static string[] Chars =
|
|
{
|
|
"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
|
|
"1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "~", "!", "@", "#", "$", "%", "^", "&", "(", ")", "-", "_", "=", "+",
|
|
"/", "?", "\\", "|", "[", "]", "{", "}", "'", "\"", ";", ":", ".", ">", ",", "<",
|
|
};
|
|
|
|
public static string Intercept()
|
|
{
|
|
Random rnd = new Random();
|
|
int shouldbeupper = rnd.Next(0, 10);
|
|
switch(shouldbeupper)
|
|
{
|
|
case 1:
|
|
case 3:
|
|
case 5:
|
|
case 7:
|
|
case 9:
|
|
return Chars[rnd.Next(0, Chars.Length - 1)].ToUpper();
|
|
break;
|
|
default:
|
|
return Chars[rnd.Next(0, Chars.Length - 1)].ToLower();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public class NotHappeningException : Exception
|
|
{
|
|
public NotHappeningException() : base("You tried to do something that ain't gonna happen.")
|
|
{
|
|
|
|
}
|
|
|
|
public NotHappeningException(string message) : base(message)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
}
|