public byte[] Input(byte[] bytes)
{
var encrypted = _encryptionService.Encrypt(bytes);
var compressed = _compressionService.Compress(encrypted.ToArray());
return(compressed);
}
public void SetWithCompression <T>(string key, T value)
{
var data = Serialize <T>(value);
var compressed = _compressionService.Compress(data);
_distributedCache.Set(key, compressed);
}
public static int Main(string[] args)
{
if (parsingService.TryParse(args))
{
int result;
switch (parsingService.CompressionMode)
{
case CompressionMode:
result = (int)compressionService.Compress(parsingService.OriginalFileName, parsingService.ResultFileName);
break;
case DecompressionMode:
result = (int)compressionService.Decompress(parsingService.OriginalFileName, parsingService.ResultFileName);
break;
default:
result = 1;
logger.Warning("Compression mode can be either 'compress' or 'decompress'");
break;
}
return(result);
}
return(1);
}
public void BigFileCompressionTest(string originalFileName, string archiveFileName, string decompressedFileName)
{
_ = compressionService.Compress(originalFileName, archiveFileName);
_ = compressionService.Decompress(archiveFileName, decompressedFileName);
Assert.True(CheckHashSum(originalFileName, decompressedFileName));
}
public Span <byte> Input(object obj)
{
var bytes = _serializerService.Serialize(obj);
bytes = _encryptionService.Encrypt(bytes);
bytes = _compressionService.Compress(bytes);
return(bytes);
}
public async Task <bool> Store(Guid documentId, IFormFile file)
{
var compressedFile = _compressionService.Compress(file);
var encryptedFile = _encryptionService.Encrypt(compressedFile);
_contentTypeProvider.TryGetContentType(file.FileName, out string contentType);
var documentContent = new DocumentContentEntity()
{
DocumentId = documentId,
Content = encryptedFile,
Length = encryptedFile.Length,
Name = file.FileName,
Type = contentType
};
return(await _repo.Store(documentContent));
}
public byte[] Encrypt(ICompressionService compress, byte[] data, uint seed, Action <double> progressFunc)
{
data = (byte[])data.Clone();
var dst = new uint[0x10];
var src = new uint[0x10];
ulong state = seed;
for (var i = 0; i < 0x10; i++)
{
state = (state * state) % 0x143fc089;
src[i] = (uint)state;
dst[i] = (uint)((state * state) % 0x444d56fb);
}
var key = Deriver.DeriveKey(dst, src);
var z = (uint)(state % 0x8a5cb7);
for (var i = 0; i < data.Length; i++)
{
data[i] ^= (byte)state;
if ((i & 0xff) == 0)
{
state = (state * state) % 0x8a5cb7;
}
}
data = compress.Compress(data, progressFunc);
Array.Resize(ref data, (data.Length + 3) & ~3);
var encryptedData = new byte[data.Length];
var keyIndex = 0;
for (var i = 0; i < data.Length; i += 4)
{
var datum = (uint)(data[i + 0] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24));
var encrypted = datum ^ key[keyIndex & 0xf];
key[keyIndex & 0xf] = (key[keyIndex & 0xf] ^ datum) + 0x3ddb2819;
encryptedData[i + 0] = (byte)(encrypted >> 0);
encryptedData[i + 1] = (byte)(encrypted >> 8);
encryptedData[i + 2] = (byte)(encrypted >> 16);
encryptedData[i + 3] = (byte)(encrypted >> 24);
keyIndex++;
}
return(encryptedData);
}
private void CompressChunk(
CompressionMode compressionMode, AsyncReadContext <QueueItem> asyncReadContext,
ConcurrentDictionary <int, byte[]> resultPieces, CancellationTokenSource exceptionSrc,
CancellationToken[] cancellationTokens,
ManualResetEventSlim outputOverflowEvent)
{
try
{
while (!cancellationTokens.Any(ct => ct.IsCancellationRequested) || asyncReadContext.Queue.Count > 0)
{
outputOverflowEvent.Wait();
if (!asyncReadContext.Queue.TryTake(out var queueItem))
{
asyncReadContext.EmptyInputEvent.Reset();
asyncReadContext.EmptyInputEvent.Wait(TimeSpan.FromMilliseconds(10));
continue;
}
byte[] data;
switch (compressionMode)
{
case CompressionMode.Compress:
data = _compressionService.Compress(queueItem.Data);
break;
case CompressionMode.Decompress:
data = _compressionService.Decompress(queueItem.Data);
break;
default:
throw new ApplicationException($"Managing of compression mode '{compressionMode}' not implemented'");
}
resultPieces.AddOrUpdate(queueItem.Order, data, (i1, byteArray) => byteArray);
ControlInputOverflow(asyncReadContext.Queue, asyncReadContext.InputOverflowEvent);
}
}
catch (Exception e)
{
_statusUpdateService.Error(e.Message);
exceptionSrc.Cancel();
}
}
public byte[] Encrypt(ICompressionService compress, byte[] data, uint seed, Action<double> progressFunc)
{
data = (byte[])data.Clone();
var dst = new uint[0x10];
var src = new uint[0x10];
ulong state = seed;
for (int i = 0; i < 0x10; i++) {
state = (state * state) % 0x143fc089;
src[i] = (uint)state;
dst[i] = (uint)((state * state) % 0x444d56fb);
}
uint[] key = Deriver.DeriveKey(dst, src);
var z = (uint)(state % 0x8a5cb7);
for (int i = 0; i < data.Length; i++) {
data[i] ^= (byte)state;
if ((i & 0xff) == 0)
state = (state * state) % 0x8a5cb7;
}
data = compress.Compress(data, progressFunc);
Array.Resize(ref data, (data.Length + 3) & ~3);
var encryptedData = new byte[data.Length];
int keyIndex = 0;
for (int i = 0; i < data.Length; i += 4) {
var datum = (uint)(data[i + 0] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24));
uint encrypted = datum ^ key[keyIndex & 0xf];
key[keyIndex & 0xf] = (key[keyIndex & 0xf] ^ datum) + 0x3ddb2819;
encryptedData[i + 0] = (byte)(encrypted >> 0);
encryptedData[i + 1] = (byte)(encrypted >> 8);
encryptedData[i + 2] = (byte)(encrypted >> 16);
encryptedData[i + 3] = (byte)(encrypted >> 24);
keyIndex++;
}
return encryptedData;
}