private static bool __isforwarded(Stream stream, NEncrypt.enc_type eType)
{
if (!stream.CanSeek)
{
return(false);
}
int num = (int)stream.Length;
if (num == 0)
{
return(false);
}
if (num < 24)
{
return(false);
}
int num2 = num;
byte[] array = new byte[num2];
BinaryReader binaryReader = new BinaryReader(stream);
array = binaryReader.ReadBytes(num);
NEncrypt.Crypto crypto = NEncrypt.Crypto.Create(eType);
bool result = false;
NEncrypt.enc_args enc_args = new NEncrypt.enc_args(eType, array, (uint)array.Length, null, false);
if (crypto != null)
{
result = crypto.IsForwarded(enc_args);
}
return(result);
}
public enc_args(NEncrypt.enc_type _type, byte[] _pSrc, uint _SrcSize, byte[] _pDest = null, bool _bDestRefPtr = false)
{
this.type = _type;
this.pSrcBuf = _pSrc;
this.nSrcSize = _SrcSize;
this.pOutBuf = _pDest;
this.bOutRefPtr = _bDestRefPtr;
}
public static bool IsForwarded(Stream stream, NEncrypt.enc_type eType)
{
bool result = NEncrypt.__isforwarded(stream, eType);
if (stream.CanSeek)
{
stream.Position = 0L;
}
return(result);
}
public static bool ProcessFile(string filename, char key = ' ', NEncrypt.PT pt = NEncrypt.PT.PT_AUTO)
{
bool result = false;
NEncrypt.enc_type enc_type = NEncrypt.enc_type.ENC_NONE;
if (pt == NEncrypt.PT.PT_DEC || pt == NEncrypt.PT.PT_AUTO)
{
enc_type = NEncrypt.IsForwarded(filename);
if (enc_type != NEncrypt.enc_type.ENC_NONE)
{
return(NEncrypt.DecryptFile(filename, enc_type, key, null));
}
}
if (pt == NEncrypt.PT.PT_ENC || pt == NEncrypt.PT.PT_AUTO)
{
string extension = Path.GetExtension(filename);
if (extension.Equals(".ntx") || extension.Equals(".ndt"))
{
enc_type = NEncrypt.enc_type.ENC_DEFAULT;
}
else if (extension.Equals(".nif"))
{
enc_type = NEncrypt.enc_type.ENC_NIF;
}
else if (extension.Equals(".dds"))
{
enc_type = NEncrypt.enc_type.ENC_DDS;
}
else if (extension.Equals(".tga"))
{
enc_type = NEncrypt.enc_type.ENC_TGA;
}
bool flag = true;
if (enc_type == NEncrypt.enc_type.ENC_NONE)
{
if (pt == NEncrypt.PT.PT_AUTO)
{
if (flag)
{
enc_type = NEncrypt.enc_type.ENC_DEFAULT;
}
}
else
{
flag = true;
enc_type = NEncrypt.enc_type.ENC_DEFAULT;
}
}
if (flag)
{
result = (NEncrypt.IsForwarded(filename, enc_type) || NEncrypt.EncryptFile(filename, enc_type, key, null));
}
}
return(result);
}
public static NEncrypt.enc_type IsForwarded(byte[] pBuffer, uint nBufSize)
{
for (NEncrypt.enc_type enc_type = NEncrypt.enc_type.ENC_DEFAULT; enc_type < NEncrypt.enc_type.ENC_END; enc_type++)
{
if (NEncrypt.IsForwarded(pBuffer, nBufSize, enc_type))
{
return(enc_type);
}
}
return(NEncrypt.enc_type.ENC_NONE);
}
public static NEncrypt.enc_type IsForwarded(Stream stream)
{
for (NEncrypt.enc_type enc_type = NEncrypt.enc_type.ENC_DEFAULT; enc_type < NEncrypt.enc_type.ENC_END; enc_type++)
{
if (NEncrypt.IsForwarded(stream, enc_type))
{
return(enc_type);
}
}
return(NEncrypt.enc_type.ENC_NONE);
}
public static NEncrypt.enc_type IsForwarded(string filename)
{
for (NEncrypt.enc_type enc_type = NEncrypt.enc_type.ENC_DEFAULT; enc_type < NEncrypt.enc_type.ENC_END; enc_type++)
{
if (NEncrypt.IsForwarded(filename, enc_type))
{
return(enc_type);
}
}
return(NEncrypt.enc_type.ENC_NONE);
}
public static bool IsForwarded(string filename, NEncrypt.enc_type eType)
{
if (!NEncrypt.IsExistFile(filename))
{
return(false);
}
FileStream fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
bool result = NEncrypt.__isforwarded(fileStream, eType);
fileStream.Close();
return(result);
}
private static bool IsForwarded(byte[] pBuffer, uint nBufSize, NEncrypt.enc_type eType)
{
NEncrypt.Crypto crypto = NEncrypt.Crypto.Create(eType);
NEncrypt.enc_args enc_args = new NEncrypt.enc_args(eType, pBuffer, nBufSize, null, false);
if (eType == NEncrypt.enc_type.ENC_DEFAULT)
{
enc_args.uiSrcFileSize = nBufSize;
}
bool result = false;
if (crypto != null)
{
result = crypto.IsForwarded(enc_args);
}
return(result);
}
public static NEncrypt.Crypto Create(NEncrypt.enc_type eType)
{
NEncrypt.Crypto result = null;
switch (eType)
{
case NEncrypt.enc_type.ENC_DEFAULT:
return(new NEncrypt._Default());
case NEncrypt.enc_type.ENC_NIF:
return(new NEncrypt._NIF());
case NEncrypt.enc_type.ENC_DDS:
return(new NEncrypt._DDS());
case NEncrypt.enc_type.ENC_TGA:
return(new NEncrypt._TGA());
default:
return(result);
}
}
private static bool Enc_Dec_File(string filename, NEncrypt.enc_type eType, NEncrypt.process_type _process_type, char key, string newfilename)
{
StreamReader streamReader = new StreamReader(new FileStream(filename, FileMode.Open));
int num = (int)streamReader.BaseStream.Length;
streamReader.Close();
byte[] array = new byte[num];
NEncrypt.enc_args enc_args = new NEncrypt.enc_args(eType, array, (uint)array.Length, null, false);
BinaryReader binaryReader = new BinaryReader(new FileStream(filename, FileMode.Open));
enc_args.pSrcBuf = binaryReader.ReadBytes(num);
enc_args.nSrcSize = (uint)num;
binaryReader.Close();
enc_args.uiSrcFileSize = (uint)num;
bool flag = false;
if (_process_type != NEncrypt.process_type.process_enc_type)
{
if (_process_type == NEncrypt.process_type.process_dec_type)
{
flag = NEncrypt.Decrypt(enc_args, key);
}
}
else
{
flag = NEncrypt.Encrypt(enc_args, key);
}
if (!flag)
{
return(false);
}
DateTime lastWriteTime = File.GetLastWriteTime(filename);
BinaryWriter binaryWriter = new BinaryWriter(new FileStream(filename, FileMode.Create));
binaryWriter.Write(enc_args.pOutBuf);
binaryWriter.Close();
File.SetLastWriteTime(filename, lastWriteTime);
return(true);
}
private static bool EncryptFile(string filename, NEncrypt.enc_type eType, char key, string newfilename = null)
{
return(NEncrypt.Enc_Dec_File(filename, eType, NEncrypt.process_type.process_enc_type, key, newfilename));
}
