459 lines
18 KiB
C#
Executable File
459 lines
18 KiB
C#
Executable File
/*using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
|
|
namespace Luski.net
|
|
{
|
|
public static class ClientEncryption
|
|
{
|
|
internal static string pw = "";
|
|
|
|
public static class File
|
|
{/*
|
|
internal static void SetOfflineKey(string key)
|
|
{
|
|
MakeFile("Server.GetKeyFilePath", pw);
|
|
LuskiDataFile? fileLayout = JsonSerializer.Deserialize<LuskiDataFile>(FileString("Server.GetKeyFilePath", pw));
|
|
fileLayout.OfflineKey = key;
|
|
fileLayout.Save("Server.GetKeyFilePath", pw);
|
|
}
|
|
|
|
|
|
|
|
internal static string? GetOfflineKey()
|
|
{
|
|
MakeFile("Server.GetKeyFilePath", pw);
|
|
LuskiDataFile? fileLayout = JsonSerializer.Deserialize<LuskiDataFile>(FileString("Server.GetKeyFilePath", pw));
|
|
return fileLayout?.OfflineKey;
|
|
}
|
|
|
|
public static LuskiDataFile GetFile()
|
|
{
|
|
MakeFile("Server.GetKeyFilePath", pw);
|
|
return JsonSerializer.Deserialize<LuskiDataFile>(FileString("Server.GetKeyFilePath", pw))!;
|
|
}
|
|
|
|
private static string FileString(string path, string password)
|
|
{
|
|
byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
|
|
byte[] salt = new byte[100];
|
|
FileStream fsCrypt = new(path, FileMode.Open);
|
|
fsCrypt.Read(salt, 0, salt.Length);
|
|
RijndaelManaged AES = new()
|
|
{
|
|
KeySize = 256,
|
|
BlockSize = 128
|
|
};
|
|
Rfc2898DeriveBytes key = new(passwordBytes, salt, 50000);
|
|
AES.Key = key.GetBytes(AES.KeySize / 8);
|
|
AES.IV = key.GetBytes(AES.BlockSize / 8);
|
|
AES.Padding = PaddingMode.PKCS7;
|
|
AES.Mode = CipherMode.CFB;
|
|
CryptoStream cs = new(fsCrypt, AES.CreateDecryptor(), CryptoStreamMode.Read);
|
|
MemoryStream fsOut = new();
|
|
int read;
|
|
byte[] buffer = new byte[1048576];
|
|
try
|
|
{
|
|
while ((read = cs.Read(buffer, 0, buffer.Length)) > 0)
|
|
{
|
|
fsOut.Write(buffer, 0, read);
|
|
}
|
|
}
|
|
catch (CryptographicException ex_CryptographicException)
|
|
{
|
|
Console.WriteLine("CryptographicException error: " + ex_CryptographicException.Message);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error: " + ex.Message);
|
|
}
|
|
fsOut.Seek(0, SeekOrigin.Begin);
|
|
using BinaryReader reader = new(fsOut);
|
|
byte[] by = reader.ReadBytes((int)fsOut.Length);
|
|
fsOut.Close();
|
|
fsCrypt.Close();
|
|
return Encoding.UTF8.GetString(by);
|
|
}
|
|
|
|
public static class Channels
|
|
{
|
|
private static string GetKey(long channel)
|
|
{
|
|
LuskiDataFile? fileLayout;
|
|
IEnumerable<ChannelLayout>? lis;
|
|
try
|
|
{
|
|
#pragma warning disable CS8603 // Possible null reference return.
|
|
// if (channel == 0) return myPrivateKey;
|
|
#pragma warning restore CS8603 // Possible null reference return.
|
|
MakeFile("Server.GetKeyFilePath", pw);
|
|
fileLayout = JsonSerializer.Deserialize<LuskiDataFile>(FileString("Server.GetKeyFilePath", pw));
|
|
lis = fileLayout?.channels?.Where(s => s.id == channel);
|
|
if (lis?.Count() > 0)
|
|
{
|
|
return lis.First().key;
|
|
}
|
|
throw new Exception("You dont have a key for that channel");
|
|
}
|
|
finally
|
|
{
|
|
fileLayout = null;
|
|
lis = null;
|
|
}
|
|
}
|
|
|
|
internal static string GetKeyBranch(long channel)
|
|
{
|
|
LuskiDataFile? fileLayout;
|
|
IEnumerable<ChannelLayout>? lis;
|
|
try
|
|
{
|
|
#pragma warning disable CS8603 // Possible null reference return.
|
|
// if (channel == 0) return myPrivateKey;
|
|
#pragma warning restore CS8603 // Possible null reference return.
|
|
MakeFile("Server.GetKeyFilePathBr(branch.ToString())", pw);
|
|
fileLayout = JsonSerializer.Deserialize<LuskiDataFile>(FileString("", pw));
|
|
lis = fileLayout?.channels?.Where(s => s.id == channel);
|
|
if (lis?.Count() > 0)
|
|
{
|
|
return lis.First().key;
|
|
}
|
|
throw new Exception("You dont have a key for that channel");
|
|
}
|
|
finally
|
|
{
|
|
fileLayout = null;
|
|
lis = null;
|
|
}
|
|
}
|
|
|
|
public static void AddKey(long channel, string key)
|
|
{
|
|
MakeFile("Server.GetKeyFilePath", pw);
|
|
LuskiDataFile? fileLayout = JsonSerializer.Deserialize<LuskiDataFile>(FileString("Server.GetKeyFilePath", pw));
|
|
fileLayout?.Addchannelkey(channel, key);
|
|
fileLayout?.Save("Server.GetKeyFilePath", pw);
|
|
}
|
|
}
|
|
|
|
private static void MakeFile(string dir, string password)
|
|
{
|
|
if (!System.IO.File.Exists(dir))
|
|
{
|
|
LuskiDataFile? l = JsonSerializer.Deserialize<LuskiDataFile>("{\"channels\":[]}");
|
|
l?.Save(dir, password);
|
|
}
|
|
}
|
|
|
|
public class LuskiDataFile
|
|
{
|
|
public static LuskiDataFile GetDataFile(string path, string password)
|
|
{
|
|
MakeFile(path, password);
|
|
return JsonSerializer.Deserialize<LuskiDataFile>(FileString(path, password));
|
|
}
|
|
|
|
internal static LuskiDataFile GetDefualtDataFile()
|
|
{
|
|
return GetDataFile("Server.GetKeyFilePath", pw);
|
|
}
|
|
|
|
public ChannelLayout[]? channels { get; set; } = default!;
|
|
|
|
public string? OfflineKey { get; set; } = default!;
|
|
|
|
public void Save(string file, string password)
|
|
{
|
|
byte[] salt = new byte[100];
|
|
RandomNumberGenerator? provider = RandomNumberGenerator.Create();
|
|
provider.GetBytes(salt);
|
|
FileStream fsCrypt = new(file, FileMode.Create);
|
|
byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
|
|
RijndaelManaged AES = new()
|
|
{
|
|
KeySize = 256,
|
|
BlockSize = 128,
|
|
Padding = PaddingMode.PKCS7
|
|
};
|
|
Rfc2898DeriveBytes key = new(passwordBytes, salt, 50000);
|
|
AES.Key = key.GetBytes(AES.KeySize / 8);
|
|
AES.IV = key.GetBytes(AES.BlockSize / 8);
|
|
AES.Mode = CipherMode.CFB;
|
|
fsCrypt.Write(salt, 0, salt.Length);
|
|
CryptoStream cs = new(fsCrypt, AES.CreateEncryptor(), CryptoStreamMode.Write);
|
|
string tempp = JsonSerializer.Serialize(this);
|
|
MemoryStream fsIn = new(Encoding.UTF8.GetBytes(tempp));
|
|
byte[] buffer = new byte[1048576];
|
|
int read;
|
|
try
|
|
{
|
|
while ((read = fsIn.Read(buffer, 0, buffer.Length)) > 0)
|
|
{
|
|
cs.Write(buffer, 0, read);
|
|
}
|
|
fsIn.Close();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine("Error: " + ex.Message);
|
|
}
|
|
finally
|
|
{
|
|
cs.Close();
|
|
fsCrypt.Close();
|
|
}
|
|
}
|
|
|
|
public void Addchannelkey(long chan, string Key)
|
|
{
|
|
List<ChannelLayout>? chans = channels?.ToList();
|
|
if (chans is null) chans = new();
|
|
if (!(chans?.Where(s => s.id == chan).Count() > 0))
|
|
{
|
|
ChannelLayout l = new()
|
|
{
|
|
id = chan,
|
|
key = Key
|
|
};
|
|
chans?.Add(l);
|
|
channels = chans?.ToArray();
|
|
}
|
|
else
|
|
{
|
|
chans.Remove(chans.Where(s => s.id == chan).First());
|
|
ChannelLayout l = new()
|
|
{
|
|
id = chan,
|
|
key = Key
|
|
};
|
|
chans?.Add(l);
|
|
channels = chans?.ToArray();
|
|
}
|
|
}
|
|
}
|
|
|
|
public class ChannelLayout
|
|
{
|
|
public long id { get; set; } = default!;
|
|
public string key { get; set; } = default!;
|
|
}
|
|
}
|
|
public class AES
|
|
{
|
|
public static string Encrypt(string path, string Password)
|
|
{
|
|
string p = Path.GetTempFileName();
|
|
byte[] salt = RandomNumberGenerator.GetBytes(100);
|
|
byte[] passwordBytes = Encoding.UTF8.GetBytes(Password);
|
|
Rfc2898DeriveBytes key = new(passwordBytes, salt, 50000);
|
|
byte[] data = System.IO.File.ReadAllBytes(path);
|
|
|
|
using Aes aesAlg = Aes.Create();
|
|
aesAlg.KeySize = 256;
|
|
aesAlg.BlockSize = 128;
|
|
aesAlg.Padding = PaddingMode.PKCS7;
|
|
aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
|
|
aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);
|
|
|
|
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
|
|
|
|
using FileStream msEncrypt = new(p, FileMode.Open);
|
|
msEncrypt.Write(salt, 0, salt.Length);
|
|
using CryptoStream csEncrypt = new(msEncrypt, encryptor, CryptoStreamMode.Write);
|
|
csEncrypt.Write(data, 0, data.Length);
|
|
csEncrypt.Dispose();
|
|
msEncrypt.Dispose();
|
|
return p;
|
|
|
|
|
|
|
|
|
|
string p = Path.GetTempFileName();
|
|
byte[] salt = new byte[100];
|
|
RNGCryptoServiceProvider provider = new();
|
|
provider.GetBytes(salt);
|
|
FileStream fsCrypt = new(p, FileMode.Open);
|
|
byte[] passwordBytes = Encoding.UTF8.GetBytes(Password);
|
|
Aes AES = Aes.Create();
|
|
AES.KeySize = 256;
|
|
AES.BlockSize = 128;
|
|
AES.Padding = PaddingMode.PKCS7;
|
|
Rfc2898DeriveBytes key = new(passwordBytes, salt, 50000);
|
|
AES.Key = key.GetBytes(AES.KeySize / 8);
|
|
AES.IV = key.GetBytes(AES.BlockSize / 8);
|
|
AES.Mode = CipherMode.CFB;
|
|
fsCrypt.Write(salt, 0, salt.Length);
|
|
key.Dispose();
|
|
CryptoStream cs = new(fsCrypt, AES.CreateEncryptor(), CryptoStreamMode.Write);
|
|
FileStream fsIn = new(path, FileMode.Open);
|
|
try
|
|
{
|
|
FileInfo FI = new(path);
|
|
byte[] buffer = new byte[FI.Length];
|
|
int read;
|
|
while ((read = fsIn.Read(buffer, 0, buffer.Length)) > 0)
|
|
{
|
|
cs.Write(buffer, 0, read);
|
|
}
|
|
}
|
|
catch (OutOfMemoryException ex)
|
|
{
|
|
throw new Exception("Buffer", ex);
|
|
}
|
|
fsIn.Close();
|
|
fsIn.Dispose();
|
|
cs.Close();
|
|
cs.Dispose();
|
|
fsCrypt.Close();
|
|
fsCrypt.Dispose();
|
|
NewPath = p;
|
|
}
|
|
|
|
public static void Decrypt(byte[] data, string Password, string File)
|
|
{
|
|
byte[] salt = new byte[100];
|
|
using MemoryStream fsCrypt = new(data);
|
|
fsCrypt.Read(salt, 0, salt.Length);
|
|
byte[] passwordBytes = Encoding.UTF8.GetBytes(Password);
|
|
Rfc2898DeriveBytes key = new(passwordBytes, salt, 50000);
|
|
byte[] decrypted = new byte[data.Length - salt.Length];
|
|
|
|
using Aes aesAlg = Aes.Create();
|
|
aesAlg.KeySize = 256;
|
|
aesAlg.BlockSize = 128;
|
|
aesAlg.Padding = PaddingMode.PKCS7;
|
|
aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
|
|
aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);
|
|
|
|
ICryptoTransform encryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
|
|
|
|
using CryptoStream csEncrypt = new(fsCrypt, encryptor, CryptoStreamMode.Read);
|
|
FileStream fsOut = new(File, FileMode.Create);
|
|
int read;
|
|
byte[] buffer = new byte[data.Length];
|
|
while ((read = csEncrypt.Read(buffer, 0, buffer.Length)) > 0)
|
|
{
|
|
fsOut.Write(buffer, 0, read);
|
|
}
|
|
csEncrypt.Dispose();
|
|
fsCrypt.Dispose();
|
|
fsOut.Dispose();
|
|
}
|
|
}
|
|
|
|
public static byte[] Hash(byte[] data)
|
|
{
|
|
return SHA256.Create().ComputeHash(data);
|
|
}
|
|
|
|
internal static byte[] Encrypt(string data)
|
|
{
|
|
return Encrypt(data, ServerPublicKey);
|
|
}
|
|
|
|
internal static byte[] Encrypt(byte[] data)
|
|
{
|
|
return Encrypt(data, ServerPublicKey);
|
|
}
|
|
|
|
internal static byte[] Encrypt(string data, string key, bool multithread = false)
|
|
{
|
|
return Encrypt(Encoder.GetBytes(data), key, multithread);
|
|
}
|
|
|
|
internal static byte[] Encrypt(byte[] data, string key, bool multithread = false)
|
|
{
|
|
using RSACryptoServiceProvider rsa = new();
|
|
rsa.FromXmlString(key);
|
|
int size = ((rsa.KeySize - 384) / 8) + 7;
|
|
double x = data.Length / (double)size;
|
|
int bbb = int.Parse(x.ToString().Split('.')[0]);
|
|
if (x.ToString().Contains('.')) bbb++;
|
|
byte[]? datasplitout = Array.Empty<byte>();
|
|
if (multithread)
|
|
{
|
|
byte[][]? decccc = Array.Empty<byte[]>();
|
|
Array.Resize(ref decccc, bbb);
|
|
int num = Convert.ToInt32(Math.Ceiling((Environment.ProcessorCount * Server.Percent) * 2.0));
|
|
if (num == 0) num = 1;
|
|
Parallel.For(0, bbb, new ParallelOptions()
|
|
{
|
|
MaxDegreeOfParallelism = num
|
|
}, i =>
|
|
{
|
|
decccc[i] = rsa.Encrypt(data.Skip(i * size).Take(size).ToArray(), true);
|
|
});
|
|
foreach (byte[] dataa in decccc)
|
|
{
|
|
datasplitout = Combine(datasplitout, dataa);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < bbb; i++)
|
|
{
|
|
datasplitout = Combine(datasplitout, rsa.Encrypt(data.Skip(i * size).Take(size).ToArray(), false));
|
|
}
|
|
}
|
|
return datasplitout;
|
|
}
|
|
|
|
private static byte[] Combine(byte[] first, byte[] second)
|
|
{
|
|
byte[]? bytes = new byte[first.Length + second.Length];
|
|
Buffer.BlockCopy(first, 0, bytes, 0, first.Length);
|
|
Buffer.BlockCopy(second, 0, bytes, first.Length, second.Length);
|
|
return bytes;
|
|
}
|
|
|
|
internal static byte[] Decrypt(byte[] EncryptedText, bool multithread = false)
|
|
{
|
|
return Decrypt(EncryptedText, myPrivateKey, multithread);
|
|
}
|
|
|
|
internal static byte[] Decrypt(byte[]? EncryptedText, string? key, bool multithread = false)
|
|
{
|
|
if (key is null) throw new ArgumentNullException(nameof(key));
|
|
if (EncryptedText is null) throw new ArgumentNullException(nameof(EncryptedText));
|
|
using RSACryptoServiceProvider rsa = new();
|
|
rsa.FromXmlString(key);
|
|
int size = rsa.KeySize / 8;
|
|
double x = EncryptedText.Length / (double)size;
|
|
int bbb = int.Parse(x.ToString().Split('.')[0]);
|
|
if (x.ToString().Contains('.')) bbb++;
|
|
byte[]? datasplitout = Array.Empty<byte>();
|
|
if (multithread)
|
|
{
|
|
byte[][]? decccc = Array.Empty<byte[]>();
|
|
Array.Resize(ref decccc, bbb);
|
|
int num = Convert.ToInt32(Math.Ceiling((Environment.ProcessorCount * Server.Percent) * 2.0));
|
|
if (num == 0) num = 1;
|
|
Parallel.For(0, bbb, new ParallelOptions()
|
|
{
|
|
MaxDegreeOfParallelism = num
|
|
}, i =>
|
|
{
|
|
decccc[i] = rsa.Decrypt(EncryptedText.Skip(i * size).Take(size).ToArray(), true);
|
|
});
|
|
foreach (byte[] data in decccc)
|
|
{
|
|
datasplitout = Combine(datasplitout, data);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < bbb; i++)
|
|
{
|
|
datasplitout = Combine(datasplitout, rsa.Decrypt(EncryptedText.Skip(i * size).Take(size).ToArray(), false));
|
|
}
|
|
}
|
|
return datasplitout;
|
|
}
|
|
}
|
|
}*/
|