trevor/SuperVPN
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init commit

Browse Source
This commit is contained in:
Andrey K. Choi
2025-10-09 09:57:24 +09:00
commit 4d551bd74f
6636 changed files with 1218703 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

539
output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Crypto/Digests/SkeinEngine.cs Normal file
View File

@@ -0,0 +1,539 @@
using System;
using System.Collections;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Utilities;
namespace Org.BouncyCastle.Crypto.Digests;
public class SkeinEngine : IMemoable
{
private class Configuration
{
private byte[] bytes = new byte[32];
public byte[] Bytes => bytes;
public Configuration(long outputSizeBits)
{
bytes[0] = 83;
bytes[1] = 72;
bytes[2] = 65;
bytes[3] = 51;
bytes[4] = 1;
bytes[5] = 0;
ThreefishEngine.WordToBytes((ulong)outputSizeBits, bytes, 8);
}
}
public class Parameter
{
private int type;
private byte[] value;
public int Type => type;
public byte[] Value => value;
public Parameter(int type, byte[] value)
{
this.type = type;
this.value = value;
}
}
private class UbiTweak
{
private const ulong LOW_RANGE = 18446744069414584320uL;
private const ulong T1_FINAL = 9223372036854775808uL;
private const ulong T1_FIRST = 4611686018427387904uL;
private ulong[] tweak = new ulong[2];
private bool extendedPosition;
public uint Type
{
get
{
return (uint)((tweak[1] >> 56) & 0x3F);
}
set
{
tweak[1] = (tweak[1] & 0xFFFFFFC000000000uL) | (((ulong)value & 0x3FuL) << 56);
}
}
public bool First
{
get
{
return (tweak[1] & 0x4000000000000000L) != 0;
}
set
{
if (value)
{
ulong[] array;
(array = tweak)[1] = array[1] | 0x4000000000000000L;
}
else
{
ulong[] array;
(array = tweak)[1] = array[1] & 0xBFFFFFFFFFFFFFFFuL;
}
}
}
public bool Final
{
get
{
return (tweak[1] & 0x8000000000000000uL) != 0;
}
set
{
if (value)
{
ulong[] array;
(array = tweak)[1] = array[1] | 0x8000000000000000uL;
}
else
{
ulong[] array;
(array = tweak)[1] = array[1] & 0x7FFFFFFFFFFFFFFFL;
}
}
}
public UbiTweak()
{
Reset();
}
public void Reset(UbiTweak tweak)
{
this.tweak = Arrays.Clone(tweak.tweak, this.tweak);
extendedPosition = tweak.extendedPosition;
}
public void Reset()
{
tweak[0] = 0uL;
tweak[1] = 0uL;
extendedPosition = false;
First = true;
}
public void AdvancePosition(int advance)
{
if (extendedPosition)
{
ulong[] array = new ulong[3]
{
tweak[0] & 0xFFFFFFFFu,
(tweak[0] >> 32) & 0xFFFFFFFFu,
tweak[1] & 0xFFFFFFFFu
};
ulong num = (ulong)advance;
for (int i = 0; i < array.Length; i++)
{
num = (array[i] = num + array[i]) >> 32;
}
tweak[0] = ((array[1] & 0xFFFFFFFFu) << 32) | (array[0] & 0xFFFFFFFFu);
tweak[1] = (tweak[1] & 0xFFFFFFFF00000000uL) | (array[2] & 0xFFFFFFFFu);
}
else
{
ulong num2 = tweak[0];
num2 += (uint)advance;
tweak[0] = num2;
if (num2 > 18446744069414584320uL)
{
extendedPosition = true;
}
}
}
public ulong[] GetWords()
{
return tweak;
}
public override string ToString()
{
return Type + " first: " + First + ", final: " + Final;
}
}
private class UBI
{
private readonly UbiTweak tweak = new UbiTweak();
private readonly SkeinEngine engine;
private byte[] currentBlock;
private int currentOffset;
private ulong[] message;
public UBI(SkeinEngine engine, int blockSize)
{
this.engine = engine;
currentBlock = new byte[blockSize];
message = new ulong[currentBlock.Length / 8];
}
public void Reset(UBI ubi)
{
currentBlock = Arrays.Clone(ubi.currentBlock, currentBlock);
currentOffset = ubi.currentOffset;
message = Arrays.Clone(ubi.message, message);
tweak.Reset(ubi.tweak);
}
public void Reset(int type)
{
tweak.Reset();
tweak.Type = (uint)type;
currentOffset = 0;
}
public void Update(byte[] value, int offset, int len, ulong[] output)
{
int num = 0;
while (len > num)
{
if (currentOffset == currentBlock.Length)
{
ProcessBlock(output);
tweak.First = false;
currentOffset = 0;
}
int num2 = System.Math.Min(len - num, currentBlock.Length - currentOffset);
Array.Copy(value, offset + num, currentBlock, currentOffset, num2);
num += num2;
currentOffset += num2;
tweak.AdvancePosition(num2);
}
}
private void ProcessBlock(ulong[] output)
{
engine.threefish.Init(forEncryption: true, engine.chain, tweak.GetWords());
for (int i = 0; i < message.Length; i++)
{
message[i] = ThreefishEngine.BytesToWord(currentBlock, i * 8);
}
engine.threefish.ProcessBlock(message, output);
for (int j = 0; j < output.Length; j++)
{
ulong[] array2;
ulong[] array = (array2 = output);
int num = j;
nint num2 = num;
array[num] = array2[num2] ^ message[j];
}
}
public void DoFinal(ulong[] output)
{
for (int i = currentOffset; i < currentBlock.Length; i++)
{
currentBlock[i] = 0;
}
tweak.Final = true;
ProcessBlock(output);
}
}
public const int SKEIN_256 = 256;
public const int SKEIN_512 = 512;
public const int SKEIN_1024 = 1024;
private const int PARAM_TYPE_KEY = 0;
private const int PARAM_TYPE_CONFIG = 4;
private const int PARAM_TYPE_MESSAGE = 48;
private const int PARAM_TYPE_OUTPUT = 63;
private static readonly IDictionary INITIAL_STATES;
private readonly ThreefishEngine threefish;
private readonly int outputSizeBytes;
private ulong[] chain;
private ulong[] initialState;
private byte[] key;
private Parameter[] preMessageParameters;
private Parameter[] postMessageParameters;
private readonly UBI ubi;
private readonly byte[] singleByte = new byte[1];
public int OutputSize => outputSizeBytes;
public int BlockSize => threefish.GetBlockSize();
static SkeinEngine()
{
INITIAL_STATES = Platform.CreateHashtable();
InitialState(256, 128, new ulong[4] { 16217771249220022880uL, 9817190399063458076uL, 1155188648486244218uL, 14769517481627992514uL });
InitialState(256, 160, new ulong[4] { 1450197650740764312uL, 3081844928540042640uL, 15310647011875280446uL, 3301952811952417661uL });
InitialState(256, 224, new ulong[4] { 14270089230798940683uL, 9758551101254474012uL, 11082101768697755780uL, 4056579644589979102uL });
InitialState(256, 256, new ulong[4] { 18202890402666165321uL, 3443677322885453875uL, 12915131351309911055uL, 7662005193972177513uL });
InitialState(512, 128, new ulong[8] { 12158729379475595090uL, 2204638249859346602uL, 3502419045458743507uL, 13617680570268287068uL, 983504137758028059uL, 1880512238245786339uL, 11730851291495443074uL, 7602827311880509485uL });
InitialState(512, 160, new ulong[8] { 2934123928682216849uL, 14047033351726823311uL, 1684584802963255058uL, 5744138295201861711uL, 2444857010922934358uL, 15638910433986703544uL, 13325156239043941114uL, 118355523173251694uL });
InitialState(512, 224, new ulong[8] { 14758403053642543652uL, 14674518637417806319uL, 10145881904771976036uL, 4146387520469897396uL, 1106145742801415120uL, 7455425944880474941uL, 11095680972475339753uL, 11397762726744039159uL });
InitialState(512, 384, new ulong[8] { 11814849197074935647uL, 12753905853581818532uL, 11346781217370868990uL, 15535391162178797018uL, 2000907093792408677uL, 9140007292425499655uL, 6093301768906360022uL, 2769176472213098488uL });
InitialState(512, 512, new ulong[8] { 5261240102383538638uL, 978932832955457283uL, 10363226125605772238uL, 11107378794354519217uL, 6752626034097301424uL, 16915020251879818228uL, 11029617608758768931uL, 12544957130904423475uL });
}
private static void InitialState(int blockSize, int outputSize, ulong[] state)
{
INITIAL_STATES.Add(VariantIdentifier(blockSize / 8, outputSize / 8), state);
}
private static int VariantIdentifier(int blockSizeBytes, int outputSizeBytes)
{
return (outputSizeBytes << 16) | blockSizeBytes;
}
public SkeinEngine(int blockSizeBits, int outputSizeBits)
{
if (outputSizeBits % 8 != 0)
{
throw new ArgumentException("Output size must be a multiple of 8 bits. :" + outputSizeBits);
}
outputSizeBytes = outputSizeBits / 8;
threefish = new ThreefishEngine(blockSizeBits);
ubi = new UBI(this, threefish.GetBlockSize());
}
public SkeinEngine(SkeinEngine engine)
: this(engine.BlockSize * 8, engine.OutputSize * 8)
{
CopyIn(engine);
}
private void CopyIn(SkeinEngine engine)
{
ubi.Reset(engine.ubi);
chain = Arrays.Clone(engine.chain, chain);
initialState = Arrays.Clone(engine.initialState, initialState);
key = Arrays.Clone(engine.key, key);
preMessageParameters = Clone(engine.preMessageParameters, preMessageParameters);
postMessageParameters = Clone(engine.postMessageParameters, postMessageParameters);
}
private static Parameter[] Clone(Parameter[] data, Parameter[] existing)
{
if (data == null)
{
return null;
}
if (existing == null || existing.Length != data.Length)
{
existing = new Parameter[data.Length];
}
Array.Copy(data, 0, existing, 0, existing.Length);
return existing;
}
public IMemoable Copy()
{
return new SkeinEngine(this);
}
public void Reset(IMemoable other)
{
SkeinEngine skeinEngine = (SkeinEngine)other;
if (BlockSize != skeinEngine.BlockSize || outputSizeBytes != skeinEngine.outputSizeBytes)
{
throw new MemoableResetException("Incompatible parameters in provided SkeinEngine.");
}
CopyIn(skeinEngine);
}
public void Init(SkeinParameters parameters)
{
chain = null;
key = null;
preMessageParameters = null;
postMessageParameters = null;
if (parameters != null)
{
byte[] array = parameters.GetKey();
if (array.Length < 16)
{
throw new ArgumentException("Skein key must be at least 128 bits.");
}
InitParams(parameters.GetParameters());
}
CreateInitialState();
UbiInit(48);
}
private void InitParams(IDictionary parameters)
{
IEnumerator enumerator = parameters.Keys.GetEnumerator();
IList list = Platform.CreateArrayList();
IList list2 = Platform.CreateArrayList();
while (enumerator.MoveNext())
{
int num = (int)enumerator.Current;
byte[] value = (byte[])parameters[num];
if (num == 0)
{
key = value;
}
else if (num < 48)
{
list.Add(new Parameter(num, value));
}
else
{
list2.Add(new Parameter(num, value));
}
}
preMessageParameters = new Parameter[list.Count];
list.CopyTo(preMessageParameters, 0);
Array.Sort((Array)preMessageParameters);
postMessageParameters = new Parameter[list2.Count];
list2.CopyTo(postMessageParameters, 0);
Array.Sort((Array)postMessageParameters);
}
private void CreateInitialState()
{
ulong[] array = (ulong[])INITIAL_STATES[VariantIdentifier(BlockSize, OutputSize)];
if (key == null && array != null)
{
chain = Arrays.Clone(array);
}
else
{
chain = new ulong[BlockSize / 8];
if (key != null)
{
UbiComplete(0, key);
}
UbiComplete(4, new Configuration(outputSizeBytes * 8).Bytes);
}
if (preMessageParameters != null)
{
for (int i = 0; i < preMessageParameters.Length; i++)
{
Parameter parameter = preMessageParameters[i];
UbiComplete(parameter.Type, parameter.Value);
}
}
initialState = Arrays.Clone(chain);
}
public void Reset()
{
Array.Copy(initialState, 0, chain, 0, chain.Length);
UbiInit(48);
}
private void UbiComplete(int type, byte[] value)
{
UbiInit(type);
ubi.Update(value, 0, value.Length, chain);
UbiFinal();
}
private void UbiInit(int type)
{
ubi.Reset(type);
}
private void UbiFinal()
{
ubi.DoFinal(chain);
}
private void CheckInitialised()
{
if (ubi == null)
{
throw new ArgumentException("Skein engine is not initialised.");
}
}
public void Update(byte inByte)
{
singleByte[0] = inByte;
Update(singleByte, 0, 1);
}
public void Update(byte[] inBytes, int inOff, int len)
{
CheckInitialised();
ubi.Update(inBytes, inOff, len, chain);
}
public int DoFinal(byte[] outBytes, int outOff)
{
CheckInitialised();
if (outBytes.Length < outOff + outputSizeBytes)
{
throw new DataLengthException("Output buffer is too short to hold output");
}
UbiFinal();
if (postMessageParameters != null)
{
for (int i = 0; i < postMessageParameters.Length; i++)
{
Parameter parameter = postMessageParameters[i];
UbiComplete(parameter.Type, parameter.Value);
}
}
int blockSize = BlockSize;
int num = (outputSizeBytes + blockSize - 1) / blockSize;
for (int j = 0; j < num; j++)
{
int outputBytes = System.Math.Min(blockSize, outputSizeBytes - j * blockSize);
Output((ulong)j, outBytes, outOff + j * blockSize, outputBytes);
}
Reset();
return outputSizeBytes;
}
private void Output(ulong outputSequence, byte[] outBytes, int outOff, int outputBytes)
{
byte[] array = new byte[8];
ThreefishEngine.WordToBytes(outputSequence, array, 0);
ulong[] array2 = new ulong[chain.Length];
UbiInit(63);
ubi.Update(array, 0, array.Length, array2);
ubi.DoFinal(array2);
int num = (outputBytes + 8 - 1) / 8;
for (int i = 0; i < num; i++)
{
int num2 = System.Math.Min(8, outputBytes - i * 8);
if (num2 == 8)
{
ThreefishEngine.WordToBytes(array2[i], outBytes, outOff + i * 8);
continue;
}
ThreefishEngine.WordToBytes(array2[i], array, 0);
Array.Copy(array, 0, outBytes, outOff + i * 8, num2);
}
}
}