public static User GetLoggedUser()
{
try
{
XmlDocument doc = new XmlDocument();
String configFileName = Utils.DirectoryAndFileHelper.SignedInUserFile;
if (File.Exists(configFileName))
{
doc.Load(configFileName);
RC4Engine encrytionEngine = new RC4Engine();
encrytionEngine.EncryptionKey = "1deageo!";
encrytionEngine.CryptedText = doc.DocumentElement.Attributes["user"].Value;
if (!encrytionEngine.Decrypt())
{
return(null);
}
if (encrytionEngine.InClearText == "-1")
{
return(null);
}
return(GetByIDUser(Convert.ToInt32(encrytionEngine.InClearText)));
}
return(null);
}
catch (Exception)
{
return(null);
}
}
public Ntlmv2Decoder(byte[] serverSigningKey, byte[] serverSealingKey)
{
_sealing = new RC4Engine();
_sealing.Init(false, new KeyParameter(serverSealingKey));
_signing = new HMACMD5(serverSigningKey);
}
private void CacheCurrentUser()
{
String userInfoFileName = DirectoryAndFileHelper.SignedInUserFile;
XmlDocument doc = new XmlDocument();
RC4Engine encryptionEngine = new RC4Engine();
encryptionEngine.EncryptionKey = "1deageo!";
encryptionEngine.InClearText = ERMTSession.Instance.CurrentUser.IDUser.ToString();
if (!encryptionEngine.Encrypt())
{
return;
}
if (File.Exists(userInfoFileName))
{
doc.Load(userInfoFileName);
doc.DocumentElement.Attributes["user"].Value = encryptionEngine.CryptedText;
}
else
{
doc.LoadXml("<Language user=\"" + encryptionEngine.CryptedText + "\" />");
}
doc.Save(userInfoFileName);
}
public static void SignOutUser()
{
try
{
XmlDocument doc = new XmlDocument();
String userInfoFileName = Utils.DirectoryAndFileHelper.SignedInUserFile;
if (File.Exists(userInfoFileName))
{
doc.Load(userInfoFileName);
RC4Engine encryptionEngine = new RC4Engine();
encryptionEngine.EncryptionKey = "1deageo!";
encryptionEngine.InClearText = "-1";
if (!encryptionEngine.Encrypt())
{
return;
}
doc.DocumentElement.Attributes["user"].Value = encryptionEngine.CryptedText;
doc.Save(userInfoFileName);
}
ERMTSession.Instance.LogoutUser();
}
catch (Exception)
{
}
}
public Ntlmv2Encoder(byte[] clientSigningKey, byte[] clientSealingKey)
{
_sealing = new RC4Engine();
_sealing.Init(true, new KeyParameter(clientSealingKey));
_signing = new HMACMD5(clientSigningKey);
}
private RC4(string key = null, string iv = null, int keyLength = Utility.DefaultGeneratedPasswordLength, bool generateIV = false)
{
this._key = key ?? Utility.GeneratePassword(keyLength);
this._iv = generateIV ? Utility.ConvertToString(Utility.GenerateIV()) : iv;
this.cipher = new RC4Engine();
cipherParams = new KeyParameter(Encoding.UTF8.GetBytes(this.Key + this.IV));
}
/// <summary>
/// Creates a new instance of an NTLM type 3 message using the specified
/// values.
/// </summary>
/// <param name="username">The Windows account name to use for
/// authentication.</param>
/// <param name="password">The Windows account password to use for
/// authentication.</param>
/// <param name="challenge">The challenge received from the server as part
/// of the NTLM type 2 message.</param>
/// <param name="useUnicode">Set this to true, if Unicode encoding has been
/// negotiated between client and server.</param>
/// <param name="workstation">The client's workstation name.</param>
/// <param name="ntlmv2">Set to true to send an NTLMv2 challenge
/// response.</param>
/// <param name="targetName">The authentication realm in which the
/// authenticating account has membership.</param>
/// <param name="targetInformation">The target information block from
/// the NTLM type 2 message.</param>
/// <remarks>The target name is a domain name for domain accounts, or
/// a server name for local machine accounts.</remarks>
/// <exception cref="ArgumentNullException">Thrown if the username, password
/// or challenge parameters are null.</exception>
public Type3Message(NetworkCredential credential, byte[] challenge,
bool useUnicode, string workstation, Flags additionalFlags = default(Flags), bool ntlmv2 = false,
string targetName = null, byte[] targetInformation = null)
{
// Preconditions.
credential.UserName.ThrowIfNull("username");
credential.Password.ThrowIfNull("password");
challenge.ThrowIfNull("challenge");
encoding = useUnicode ? Encoding.Unicode : Encoding.ASCII;
// Setup the security buffers contents.
this.username = encoding.GetBytes(credential.UserName);
this.workstation = encoding.GetBytes(workstation);
this.targetName = String.IsNullOrEmpty(targetName) ? new byte[0] :
encoding.GetBytes(targetName);
// The session key is not relevant to authentication.
this.sessionKey = new byte[0];
// Compute the actual challenge response data.
if (!ntlmv2)
{
LMResponse = Responses.ComputeLMResponse(challenge, credential.Password);
NtlmResponse = Responses.ComputeNtlmResponse(challenge, credential.Password);
}
else
{
byte[] cnonce = GetCNonce();
LMResponse = Responses.ComputeLMv2Response(targetName, credential, challenge, cnonce);
var ntlmv2Hash = Responses.Ntlmv2Hash(targetName, credential);
NtlmResponse = Responses.ComputeNtlmv2Response(ntlmv2Hash, targetInformation, challenge, cnonce);
Flags |= additionalFlags;
using (var hmac = new HMACMD5(ntlmv2Hash))
{
var userSessionKey = hmac.ComputeHash(NtlmResponse, 0, 16);
if ((Flags & Flags.NegotiateSeal) != default(Flags) || (Flags & Flags.NegotiateSign) != default(Flags))
{
// Sealing or signing required
if ((Flags & Flags.NegotiateKeyExchange) != default(Flags))
{
// Key exchange initiated so need to generate a new key
var cipher = new RC4Engine();
cipher.Init(true, new KeyParameter(userSessionKey));
SessionKey = new byte[16];
using (var rnd = RandomNumberGenerator.Create())
rnd.GetBytes(SessionKey);
sessionKey = new byte[16];
cipher.ProcessBytes(SessionKey, 0, SessionKey.Length, sessionKey, 0);
}
else
{
// NTLMv2 User Session Key used
SessionKey = userSessionKey;
}
}
}
}
// We spoof an OS version of Windows 7 Build 7601.
OSVersion = new OSVersion(6, 1, 7601);
}
public ARC4(byte[] sessionKey, bool forEncryption)
{
this.rc4 = new RC4Engine();
this.rc4.Init(forEncryption, new KeyParameter(sessionKey));
// Drop first 1024 bytes
this.ProcessBytes(new byte[1024]);
}
/// <summary>
/// 将有效的RC4编码字符串转换到等效字符串表示形式。
/// </summary>
/// <param name="value">欲被转换的字符串</param>
/// <returns></returns>
public static string FromRC4String(this string value, string key)
{
if (string.IsNullOrEmpty(value) || string.IsNullOrEmpty(key))
{
return(string.Empty);
}
return(RC4Engine.RC4Create(key, value));
}
protected internal RC4Engine GetEngine()
{
if (_engine == null)
{
_engine = new RC4Engine();
}
return(_engine);
}
/// <summary>
/// Decodes the page in the given buffer (in place) using RC4 decryption with
/// the given params.
/// </summary>
/// <remarks>
/// Decodes the page in the given buffer (in place) using RC4 decryption with
/// the given params.
/// </remarks>
/// <param name="buffer">encoded page buffer</param>
/// <param name="params">RC4 decryption parameters</param>
protected internal virtual void DecodePage(ByteBuffer buffer, KeyParameter @params
)
{
RC4Engine engine = GetEngine();
engine.Init(false, @params);
byte[] array = ((byte[])buffer.Array());
engine.ProcessBytes(array, 0, array.Length, array, 0);
}
/// <summary>
/// Creates a new RC4 service with the provided <see cref="key"/>.
/// </summary>
/// <param name="key">The RC4 key.</param>
public RC4CryptoServiceProvider([NotNull] byte[] key, bool forEncryption)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
//Bouncy requires key initialization
internalRC4Engine = new RC4Engine();
internalRC4Engine.Init(forEncryption, new KeyParameter(key));
}
/// <summary>
///
/// </summary>
/// <param name="bootKey"></param>
/// <returns></returns>
private byte[] GenerateHashedBootKey(List <byte> bootKey)
{
try
{
RegParser regParser = new RegParser(_samFile);
RegKey rootKey = regParser.RootKey;
RegKey regKey = rootKey.Key(@"SAM\Domains\Account");
if (regKey == null)
{
this.OnError("Unable to locate the following registry key: SAM\\SAM\\Domains\\Account");
return(null);
}
RegValue regValue = regKey.Value("F");
if (regValue == null)
{
this.OnError("Unable to locate the following registry key: SAM\\SAM\\Domains\\Account\\F");
return(null);
}
byte[] hashedBootKey = new byte[16];
Buffer.BlockCopy((byte[])regValue.Data, 112, hashedBootKey, 0, 16);
//this.PrintHex("Hashed bootkey", hashedBootKey.ToArray());
List <byte> data = new List <byte>();
data.AddRange(hashedBootKey.ToArray());
data.AddRange(Encoding.ASCII.GetBytes(_aqwerty));
data.AddRange(bootKey.ToArray());
data.AddRange(Encoding.ASCII.GetBytes(_anum));
byte[] md5 = MD5.Create().ComputeHash(data.ToArray());
byte[] encData = new byte[32];
byte[] encOutput = new byte[32];
Buffer.BlockCopy((byte[])regValue.Data, 128, encData, 0, 32);
RC4Engine rc4Engine = new RC4Engine();
rc4Engine.Init(true, new KeyParameter(md5));
rc4Engine.ProcessBytes(encData, 0, 32, encOutput, 0);
return(encOutput);
}
catch (Exception ex)
{
this.OnError("An error occured whilst generating the hashed boot key");
Misc.WriteToEventLog(Application.ProductName, ex.Message, EventLogEntryType.Error);
return(null);
}
}
public void ThreadRun()
{
int i = 0;
byte[] clearText = new byte[kryptogram.Length];
string czescKlucza1 = "";
while (i <= szukaj.max)
{
i = szukaj.wykonane();
if (i <= szukaj.max)
{
czescKlucza1 = i.ToString("X");
while (czescKlucza1.Length < 8)
{
czescKlucza1 = "0" + czescKlucza1;
}
String klucz = czescKlucza1.ToLower() + czescKlucza2;
try
{
RC4Engine rc4 = new RC4Engine();
KeyParameter keyParam = new KeyParameter(System.Text.Encoding.ASCII.GetBytes(klucz));
rc4.Init(false, keyParam);
rc4.ProcessBytes(kryptogram, 0, kryptogram.Length, clearText, 0);
}
catch (Exception e)
{
}
bool zgodne = true;
for (int j = 0; j < clearText.Length; j++)
{
if (!alfabet.lista_znakow.Contains((char)clearText[j]))
{
zgodne = false;
}
}
//jeśli znalazl dobry klucz
if (zgodne)
{
Console.Write("Wiadomosc : ");
foreach (byte x in clearText)
{
Console.Write("{0} ", (char)x);
}
Console.WriteLine("");
Console.WriteLine(" klucz: {0}", klucz);
szukaj.ileZrobiono = szukaj.max;
}
}
}
}
private void VerifyPassword(ByteBuffer buffer, byte[] testEncodingKey, byte[] testBytes
)
{
RC4Engine engine = GetEngine();
engine.Init(false, new KeyParameter(testEncodingKey));
byte[] encrypted4BytesCheck = GetPasswordTestBytes(buffer);
byte[] decrypted4BytesCheck = new byte[4];
engine.ProcessBytes(encrypted4BytesCheck, 0, encrypted4BytesCheck.Length, decrypted4BytesCheck
, 0);
if (!Arrays.Equals(decrypted4BytesCheck, testBytes))
{
throw new InvalidOperationException("Incorrect password provided");
}
}
private void InitEngine()
{
if (_config.CipherAlgorithm == CipherAlgorithm.RC4)
{
_myRc4 = new RC4Engine();
}
else
{
_myAes = new AesEngine();
if (_config.IvOrSalt == null && _config.BlockMode != BlockMode.ECB)
{
_config.IvOrSalt = GenerateIv();
}
}
}
/// <summary>
/// Encrypt a string using RC4 algorithm
/// </summary>
/// <param name="Data">Original string</param>
/// <param name="Salt">Random data</param>
/// <returns>HEX encoded encrypted string literal</returns>
public static string EncryptWithRC4(string Data, string Salt = "")
{
// URL encode string to preserve foriegn characters and NON-ANSI characters
Data = System.Net.WebUtility.UrlEncode(Data);
// Encrypt string
RC4Engine RC4 = new RC4Engine();
RC4.EncryptionKey = Config.EncryptionPassword + Salt + Config.EncryptionSalt;
RC4.InClearText = Data;
RC4.Encrypt();
string Encrypted = RC4.CryptedText;
// Convert to HEX
return(ConvertToHexString(Encrypted));
}
/// <summary>
/// Decrypt a string using RC4 algorithm
/// </summary>
/// <param name="Data">HEX encoded encrypted string</param>
/// <param name="Salt">Random data</param>
/// <returns>Decrypted string literal</returns>
public static string DecryptWithRC4(string Data, string Salt = "")
{
// Convert from HEX
Data = ConvertFromHexString(Data);
// Decrypt string
RC4Engine RC4 = new RC4Engine();
RC4.EncryptionKey = Config.EncryptionPassword + Salt + Config.EncryptionSalt;
RC4.CryptedText = Data;
RC4.Decrypt();
string Decrypted = RC4.InClearText;
// URL decode
return(System.Net.WebUtility.UrlDecode(Decrypted));
}
private static string RC4Create(string key, string value)
{
char[] buffer = value.ToCharArray();
byte[] box = RC4Engine.RC4Init(key);
for (int i = 0, low = 0, high = 0, mid; i < buffer.Length; i++)
{
low = (low + key.Length) % byte.MaxValue;
high = (high + box[i % byte.MaxValue]) % byte.MaxValue;
byte b = box[low];
box[low] = box[high];
box[high] = b;
mid = (box[low] + box[high]) % byte.MaxValue;
buffer[i] ^= (char)box[mid];
}
return(new string(buffer));
}
/********EXTERNAL OBJECT PUBLIC METHODS - END ********/
/// <summary>
/// Buils the StreamCipher
/// </summary>
/// <param name="algorithm">SymmetrcStreamAlgorithm enum, algorithm name</param>
/// <returns>IStreamCipher with the algorithm Stream Engine</returns>
private IStreamCipher getCipherEngine(SymmetricStreamAlgorithm algorithm)
{
IStreamCipher engine = null;
switch (algorithm)
{
case SymmetricStreamAlgorithm.RC4:
engine = new RC4Engine();
break;
case SymmetricStreamAlgorithm.HC128:
engine = new HC128Engine();
break;
case SymmetricStreamAlgorithm.HC256:
engine = new HC256Engine();
break;
case SymmetricStreamAlgorithm.SALSA20:
engine = new Salsa20Engine();
break;
case SymmetricStreamAlgorithm.CHACHA20:
engine = new ChaChaEngine();
break;
case SymmetricStreamAlgorithm.XSALSA20:
engine = new XSalsa20Engine();
break;
case SymmetricStreamAlgorithm.ISAAC:
engine = new IsaacEngine();
break;
case SymmetricStreamAlgorithm.VMPC:
engine = new VmpcEngine();
break;
default:
this.GetError().setError("SS005", "Cipher " + algorithm + " not recognised.");
break;
}
return(engine);
}
static void Main(string[] args)
{
if (args[0] == "-d")
{
FileStream fs = new FileStream(args[1], FileMode.OpenOrCreate, FileAccess.ReadWrite);
int keyLen = readInt32BE(fs);
Console.WriteLine("KeyLen: " + keyLen.ToString());
byte[] key = new byte[keyLen];
fs.Read(key, 0, keyLen);
long Remaining = fs.Length - fs.Position;
Console.WriteLine("Remaining: " + Remaining.ToString());
byte[] data = new byte[Remaining];
byte[] data2 = new byte[Remaining];
fs.Read(data, 0, (int)Remaining);
RC4Engine ARC4 = new RC4Engine();
ARC4.Init(false, new KeyParameter(key));
ARC4.ProcessBytes(data, 0, data.Length, data2, 0);
Byte[] DecompressedData = ZlibStream.UncompressBuffer(data2);
File.WriteAllBytes(args[2], DecompressedData);
}
else if (args[0] == "-e")
{
FileStream fs = new FileStream(args[2], FileMode.OpenOrCreate, FileAccess.ReadWrite);
int keyLen = readInt32BE(fs);
Console.WriteLine("KeyLen: " + keyLen.ToString());
byte[] key = new byte[keyLen];
fs.Read(key, 0, keyLen);
Byte[] PlaintextData = File.ReadAllBytes(args[1]);
Byte[] CompressedData = ZlibStream.CompressBuffer(PlaintextData);
Byte[] EncryptedData = new Byte[CompressedData.Length];
RC4Engine ARC4 = new RC4Engine();
ARC4.Init(false, new KeyParameter(key));
ARC4.ProcessBytes(CompressedData, 0, CompressedData.Length, EncryptedData, 0);
fs.SetLength(fs.Position);
fs.Write(EncryptedData, 0, EncryptedData.Length);
fs.Close();
}
}
public static IBufferedCipher GetCipher(
string algorithm)
{
if (algorithm == null)
{
throw new ArgumentNullException("algorithm");
}
algorithm = Platform.ToUpperInvariant(algorithm);
{
string aliased = (string)algorithms[algorithm];
if (aliased != null)
{
algorithm = aliased;
}
}
IBasicAgreement iesAgreement = null;
if (algorithm == "IES")
{
iesAgreement = new DHBasicAgreement();
}
else if (algorithm == "ECIES")
{
iesAgreement = new ECDHBasicAgreement();
}
if (iesAgreement != null)
{
return(new BufferedIesCipher(
new IesEngine(
iesAgreement,
new Kdf2BytesGenerator(
new Sha1Digest()),
new HMac(
new Sha1Digest()))));
}
if (Platform.StartsWith(algorithm, "PBE"))
{
if (Platform.EndsWith(algorithm, "-CBC"))
{
if (algorithm == "PBEWITHSHA1ANDDES-CBC")
{
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new DesEngine())));
}
else if (algorithm == "PBEWITHSHA1ANDRC2-CBC")
{
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new RC2Engine())));
}
else if (Strings.IsOneOf(algorithm,
"PBEWITHSHAAND2-KEYTRIPLEDES-CBC", "PBEWITHSHAAND3-KEYTRIPLEDES-CBC"))
{
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new DesEdeEngine())));
}
else if (Strings.IsOneOf(algorithm,
"PBEWITHSHAAND128BITRC2-CBC", "PBEWITHSHAAND40BITRC2-CBC"))
{
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new RC2Engine())));
}
}
else if (Platform.EndsWith(algorithm, "-BC") || Platform.EndsWith(algorithm, "-OPENSSL"))
{
if (Strings.IsOneOf(algorithm,
"PBEWITHSHAAND128BITAES-CBC-BC",
"PBEWITHSHAAND192BITAES-CBC-BC",
"PBEWITHSHAAND256BITAES-CBC-BC",
"PBEWITHSHA256AND128BITAES-CBC-BC",
"PBEWITHSHA256AND192BITAES-CBC-BC",
"PBEWITHSHA256AND256BITAES-CBC-BC",
"PBEWITHMD5AND128BITAES-CBC-OPENSSL",
"PBEWITHMD5AND192BITAES-CBC-OPENSSL",
"PBEWITHMD5AND256BITAES-CBC-OPENSSL"))
{
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new AesFastEngine())));
}
}
}
string[] parts = algorithm.Split('/');
IBlockCipher blockCipher = null;
IAsymmetricBlockCipher asymBlockCipher = null;
IStreamCipher streamCipher = null;
string algorithmName = parts[0];
{
string aliased = (string)algorithms[algorithmName];
if (aliased != null)
{
algorithmName = aliased;
}
}
CipherAlgorithm cipherAlgorithm;
try
{
cipherAlgorithm = (CipherAlgorithm)Enums.GetEnumValue(typeof(CipherAlgorithm), algorithmName);
}
catch (ArgumentException)
{
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
switch (cipherAlgorithm)
{
case CipherAlgorithm.AES:
blockCipher = new AesFastEngine();
break;
case CipherAlgorithm.ARC4:
streamCipher = new RC4Engine();
break;
case CipherAlgorithm.BLOWFISH:
blockCipher = new BlowfishEngine();
break;
case CipherAlgorithm.CAMELLIA:
blockCipher = new CamelliaEngine();
break;
case CipherAlgorithm.CAST5:
blockCipher = new Cast5Engine();
break;
case CipherAlgorithm.CAST6:
blockCipher = new Cast6Engine();
break;
case CipherAlgorithm.DES:
blockCipher = new DesEngine();
break;
case CipherAlgorithm.DESEDE:
blockCipher = new DesEdeEngine();
break;
case CipherAlgorithm.ELGAMAL:
asymBlockCipher = new ElGamalEngine();
break;
case CipherAlgorithm.GOST28147:
blockCipher = new Gost28147Engine();
break;
case CipherAlgorithm.HC128:
streamCipher = new HC128Engine();
break;
case CipherAlgorithm.HC256:
streamCipher = new HC256Engine();
break;
case CipherAlgorithm.IDEA:
blockCipher = new IdeaEngine();
break;
case CipherAlgorithm.NOEKEON:
blockCipher = new NoekeonEngine();
break;
case CipherAlgorithm.PBEWITHSHAAND128BITRC4:
case CipherAlgorithm.PBEWITHSHAAND40BITRC4:
streamCipher = new RC4Engine();
break;
case CipherAlgorithm.RC2:
blockCipher = new RC2Engine();
break;
case CipherAlgorithm.RC5:
blockCipher = new RC532Engine();
break;
case CipherAlgorithm.RC5_64:
blockCipher = new RC564Engine();
break;
case CipherAlgorithm.RC6:
blockCipher = new RC6Engine();
break;
case CipherAlgorithm.RIJNDAEL:
blockCipher = new RijndaelEngine();
break;
case CipherAlgorithm.RSA:
asymBlockCipher = new RsaBlindedEngine();
break;
case CipherAlgorithm.SALSA20:
streamCipher = new Salsa20Engine();
break;
case CipherAlgorithm.SEED:
blockCipher = new SeedEngine();
break;
case CipherAlgorithm.SERPENT:
blockCipher = new SerpentEngine();
break;
case CipherAlgorithm.SKIPJACK:
blockCipher = new SkipjackEngine();
break;
case CipherAlgorithm.TEA:
blockCipher = new TeaEngine();
break;
case CipherAlgorithm.THREEFISH_256:
blockCipher = new ThreefishEngine(ThreefishEngine.BLOCKSIZE_256);
break;
case CipherAlgorithm.THREEFISH_512:
blockCipher = new ThreefishEngine(ThreefishEngine.BLOCKSIZE_512);
break;
case CipherAlgorithm.THREEFISH_1024:
blockCipher = new ThreefishEngine(ThreefishEngine.BLOCKSIZE_1024);
break;
case CipherAlgorithm.TNEPRES:
blockCipher = new TnepresEngine();
break;
case CipherAlgorithm.TWOFISH:
blockCipher = new TwofishEngine();
break;
case CipherAlgorithm.VMPC:
streamCipher = new VmpcEngine();
break;
case CipherAlgorithm.VMPC_KSA3:
streamCipher = new VmpcKsa3Engine();
break;
case CipherAlgorithm.XTEA:
blockCipher = new XteaEngine();
break;
default:
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
if (streamCipher != null)
{
if (parts.Length > 1)
{
throw new ArgumentException("Modes and paddings not used for stream ciphers");
}
return(new BufferedStreamCipher(streamCipher));
}
bool cts = false;
bool padded = true;
IBlockCipherPadding padding = null;
IAeadBlockCipher aeadBlockCipher = null;
if (parts.Length > 2)
{
if (streamCipher != null)
{
throw new ArgumentException("Paddings not used for stream ciphers");
}
string paddingName = parts[2];
CipherPadding cipherPadding;
if (paddingName == "")
{
cipherPadding = CipherPadding.RAW;
}
else if (paddingName == "X9.23PADDING")
{
cipherPadding = CipherPadding.X923PADDING;
}
else
{
try
{
cipherPadding = (CipherPadding)Enums.GetEnumValue(typeof(CipherPadding), paddingName);
}
catch (ArgumentException)
{
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
}
switch (cipherPadding)
{
case CipherPadding.NOPADDING:
padded = false;
break;
case CipherPadding.RAW:
break;
case CipherPadding.ISO10126PADDING:
case CipherPadding.ISO10126D2PADDING:
case CipherPadding.ISO10126_2PADDING:
padding = new ISO10126d2Padding();
break;
case CipherPadding.ISO7816_4PADDING:
case CipherPadding.ISO9797_1PADDING:
padding = new ISO7816d4Padding();
break;
case CipherPadding.ISO9796_1:
case CipherPadding.ISO9796_1PADDING:
asymBlockCipher = new ISO9796d1Encoding(asymBlockCipher);
break;
case CipherPadding.OAEP:
case CipherPadding.OAEPPADDING:
asymBlockCipher = new OaepEncoding(asymBlockCipher);
break;
case CipherPadding.OAEPWITHMD5ANDMGF1PADDING:
asymBlockCipher = new OaepEncoding(asymBlockCipher, new MD5Digest());
break;
case CipherPadding.OAEPWITHSHA1ANDMGF1PADDING:
case CipherPadding.OAEPWITHSHA_1ANDMGF1PADDING:
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha1Digest());
break;
case CipherPadding.OAEPWITHSHA224ANDMGF1PADDING:
case CipherPadding.OAEPWITHSHA_224ANDMGF1PADDING:
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha224Digest());
break;
case CipherPadding.OAEPWITHSHA256ANDMGF1PADDING:
case CipherPadding.OAEPWITHSHA_256ANDMGF1PADDING:
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha256Digest());
break;
case CipherPadding.OAEPWITHSHA384ANDMGF1PADDING:
case CipherPadding.OAEPWITHSHA_384ANDMGF1PADDING:
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha384Digest());
break;
case CipherPadding.OAEPWITHSHA512ANDMGF1PADDING:
case CipherPadding.OAEPWITHSHA_512ANDMGF1PADDING:
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha512Digest());
break;
case CipherPadding.PKCS1:
case CipherPadding.PKCS1PADDING:
asymBlockCipher = new Pkcs1Encoding(asymBlockCipher);
break;
case CipherPadding.PKCS5:
case CipherPadding.PKCS5PADDING:
case CipherPadding.PKCS7:
case CipherPadding.PKCS7PADDING:
padding = new Pkcs7Padding();
break;
case CipherPadding.TBCPADDING:
padding = new TbcPadding();
break;
case CipherPadding.WITHCTS:
cts = true;
break;
case CipherPadding.X923PADDING:
padding = new X923Padding();
break;
case CipherPadding.ZEROBYTEPADDING:
padding = new ZeroBytePadding();
break;
default:
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
}
string mode = "";
if (parts.Length > 1)
{
mode = parts[1];
int di = GetDigitIndex(mode);
string modeName = di >= 0 ? mode.Substring(0, di) : mode;
try
{
CipherMode cipherMode = modeName == ""
? CipherMode.NONE
: (CipherMode)Enums.GetEnumValue(typeof(CipherMode), modeName);
switch (cipherMode)
{
case CipherMode.ECB:
case CipherMode.NONE:
break;
case CipherMode.CBC:
blockCipher = new CbcBlockCipher(blockCipher);
break;
case CipherMode.CCM:
aeadBlockCipher = new CcmBlockCipher(blockCipher);
break;
case CipherMode.CFB:
{
int bits = (di < 0)
? 8 * blockCipher.GetBlockSize()
: int.Parse(mode.Substring(di));
blockCipher = new CfbBlockCipher(blockCipher, bits);
break;
}
case CipherMode.CTR:
blockCipher = new SicBlockCipher(blockCipher);
break;
case CipherMode.CTS:
cts = true;
blockCipher = new CbcBlockCipher(blockCipher);
break;
case CipherMode.EAX:
aeadBlockCipher = new EaxBlockCipher(blockCipher);
break;
case CipherMode.GCM:
aeadBlockCipher = new GcmBlockCipher(blockCipher);
break;
case CipherMode.GOFB:
blockCipher = new GOfbBlockCipher(blockCipher);
break;
case CipherMode.OCB:
aeadBlockCipher = new OcbBlockCipher(blockCipher, CreateBlockCipher(cipherAlgorithm));
break;
case CipherMode.OFB:
{
int bits = (di < 0)
? 8 * blockCipher.GetBlockSize()
: int.Parse(mode.Substring(di));
blockCipher = new OfbBlockCipher(blockCipher, bits);
break;
}
case CipherMode.OPENPGPCFB:
blockCipher = new OpenPgpCfbBlockCipher(blockCipher);
break;
case CipherMode.SIC:
if (blockCipher.GetBlockSize() < 16)
{
throw new ArgumentException("Warning: SIC-Mode can become a twotime-pad if the blocksize of the cipher is too small. Use a cipher with a block size of at least 128 bits (e.g. AES)");
}
blockCipher = new SicBlockCipher(blockCipher);
break;
default:
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
}
catch (ArgumentException)
{
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
}
if (aeadBlockCipher != null)
{
if (cts)
{
throw new SecurityUtilityException("CTS mode not valid for AEAD ciphers.");
}
if (padded && parts.Length > 2 && parts[2] != "")
{
throw new SecurityUtilityException("Bad padding specified for AEAD cipher.");
}
return(new BufferedAeadBlockCipher(aeadBlockCipher));
}
if (blockCipher != null)
{
if (cts)
{
return(new CtsBlockCipher(blockCipher));
}
if (padding != null)
{
return(new PaddedBufferedBlockCipher(blockCipher, padding));
}
if (!padded || blockCipher.IsPartialBlockOkay)
{
return(new BufferedBlockCipher(blockCipher));
}
return(new PaddedBufferedBlockCipher(blockCipher));
}
if (asymBlockCipher != null)
{
return(new BufferedAsymmetricBlockCipher(asymBlockCipher));
}
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
public RC4(byte[] key)
{
rc4 = new RC4Engine();
rc4.Init(true, new KeyParameter(key));
}
/// <summary>
/// 将有效的字符串转换为 RC4 编码的等效字符串表示形式。
/// </summary>
/// <param name="value">欲被转换的字符串</param>
/// <returns></returns>
public static string ToRC4String(this string value, string key)
{
return(RC4Engine.FromRC4String(value, key));
}
public BcRC4Crypto(byte[] key)
{
_rc4 = new RC4Engine();
_rc4.Init(default, new KeyParameter(key));
public static IBufferedCipher GetCipher(
string algorithm)
{
if (algorithm == null)
{
throw new ArgumentNullException("algorithm");
}
algorithm = algorithm.ToUpper(CultureInfo.InvariantCulture);
string aliased = (string)algorithms[algorithm];
if (aliased != null)
{
algorithm = aliased;
}
IBasicAgreement iesAgreement = null;
if (algorithm == "IES")
{
iesAgreement = new DHBasicAgreement();
}
else if (algorithm == "ECIES")
{
iesAgreement = new ECDHBasicAgreement();
}
if (iesAgreement != null)
{
return(new BufferedIesCipher(
new IesEngine(
iesAgreement,
new Kdf2BytesGenerator(
new Sha1Digest()),
new HMac(
new Sha1Digest()))));
}
if (algorithm.StartsWith("PBE"))
{
switch (algorithm)
{
case "PBEWITHSHAAND2-KEYTRIPLEDES-CBC":
case "PBEWITHSHAAND3-KEYTRIPLEDES-CBC":
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new DesEdeEngine())));
case "PBEWITHSHAAND128BITRC2-CBC":
case "PBEWITHSHAAND40BITRC2-CBC":
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new RC2Engine())));
case "PBEWITHSHAAND128BITAES-CBC-BC":
case "PBEWITHSHAAND192BITAES-CBC-BC":
case "PBEWITHSHAAND256BITAES-CBC-BC":
case "PBEWITHSHA256AND128BITAES-CBC-BC":
case "PBEWITHSHA256AND192BITAES-CBC-BC":
case "PBEWITHSHA256AND256BITAES-CBC-BC":
case "PBEWITHMD5AND128BITAES-CBC-OPENSSL":
case "PBEWITHMD5AND192BITAES-CBC-OPENSSL":
case "PBEWITHMD5AND256BITAES-CBC-OPENSSL":
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new AesFastEngine())));
case "PBEWITHSHA1ANDDES-CBC":
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new DesEngine())));
case "PBEWITHSHA1ANDRC2-CBC":
return(new PaddedBufferedBlockCipher(
new CbcBlockCipher(new RC2Engine())));
}
}
string[] parts = algorithm.Split('/');
IBlockCipher blockCipher = null;
IAsymmetricBlockCipher asymBlockCipher = null;
IStreamCipher streamCipher = null;
switch (parts[0])
{
case "AES":
blockCipher = new AesFastEngine();
break;
case "ARC4":
streamCipher = new RC4Engine();
break;
case "BLOWFISH":
blockCipher = new BlowfishEngine();
break;
case "CAMELLIA":
blockCipher = new CamelliaEngine();
break;
case "CAST5":
blockCipher = new Cast5Engine();
break;
case "CAST6":
blockCipher = new Cast6Engine();
break;
case "DES":
blockCipher = new DesEngine();
break;
case "DESEDE":
blockCipher = new DesEdeEngine();
break;
case "ELGAMAL":
asymBlockCipher = new ElGamalEngine();
break;
case "GOST28147":
blockCipher = new Gost28147Engine();
break;
case "HC128":
streamCipher = new HC128Engine();
break;
case "HC256":
streamCipher = new HC256Engine();
break;
#if INCLUDE_IDEA
case "IDEA":
blockCipher = new IdeaEngine();
break;
#endif
case "NOEKEON":
blockCipher = new NoekeonEngine();
break;
case "PBEWITHSHAAND128BITRC4":
case "PBEWITHSHAAND40BITRC4":
streamCipher = new RC4Engine();
break;
case "RC2":
blockCipher = new RC2Engine();
break;
case "RC5":
blockCipher = new RC532Engine();
break;
case "RC5-64":
blockCipher = new RC564Engine();
break;
case "RC6":
blockCipher = new RC6Engine();
break;
case "RIJNDAEL":
blockCipher = new RijndaelEngine();
break;
case "RSA":
asymBlockCipher = new RsaBlindedEngine();
break;
case "SALSA20":
streamCipher = new Salsa20Engine();
break;
case "SEED":
blockCipher = new SeedEngine();
break;
case "SERPENT":
blockCipher = new SerpentEngine();
break;
case "SKIPJACK":
blockCipher = new SkipjackEngine();
break;
case "TEA":
blockCipher = new TeaEngine();
break;
case "TWOFISH":
blockCipher = new TwofishEngine();
break;
case "VMPC":
streamCipher = new VmpcEngine();
break;
case "VMPC-KSA3":
streamCipher = new VmpcKsa3Engine();
break;
case "XTEA":
blockCipher = new XteaEngine();
break;
default:
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
if (streamCipher != null)
{
if (parts.Length > 1)
{
throw new ArgumentException("Modes and paddings not used for stream ciphers");
}
return(new BufferedStreamCipher(streamCipher));
}
bool cts = false;
bool padded = true;
IBlockCipherPadding padding = null;
IAeadBlockCipher aeadBlockCipher = null;
if (parts.Length > 2)
{
if (streamCipher != null)
{
throw new ArgumentException("Paddings not used for stream ciphers");
}
switch (parts[2])
{
case "NOPADDING":
padded = false;
break;
case "":
case "RAW":
break;
case "ISO10126PADDING":
case "ISO10126D2PADDING":
case "ISO10126-2PADDING":
padding = new ISO10126d2Padding();
break;
case "ISO7816-4PADDING":
case "ISO9797-1PADDING":
padding = new ISO7816d4Padding();
break;
case "ISO9796-1":
case "ISO9796-1PADDING":
asymBlockCipher = new ISO9796d1Encoding(asymBlockCipher);
break;
case "OAEP":
case "OAEPPADDING":
asymBlockCipher = new OaepEncoding(asymBlockCipher);
break;
case "OAEPWITHMD5ANDMGF1PADDING":
asymBlockCipher = new OaepEncoding(asymBlockCipher, new MD5Digest());
break;
case "OAEPWITHSHA1ANDMGF1PADDING":
case "OAEPWITHSHA-1ANDMGF1PADDING":
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha1Digest());
break;
case "OAEPWITHSHA224ANDMGF1PADDING":
case "OAEPWITHSHA-224ANDMGF1PADDING":
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha224Digest());
break;
case "OAEPWITHSHA256ANDMGF1PADDING":
case "OAEPWITHSHA-256ANDMGF1PADDING":
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha256Digest());
break;
case "OAEPWITHSHA384ANDMGF1PADDING":
case "OAEPWITHSHA-384ANDMGF1PADDING":
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha384Digest());
break;
case "OAEPWITHSHA512ANDMGF1PADDING":
case "OAEPWITHSHA-512ANDMGF1PADDING":
asymBlockCipher = new OaepEncoding(asymBlockCipher, new Sha512Digest());
break;
case "PKCS1":
case "PKCS1PADDING":
asymBlockCipher = new Pkcs1Encoding(asymBlockCipher);
break;
case "PKCS5":
case "PKCS5PADDING":
case "PKCS7":
case "PKCS7PADDING":
// NB: Padding defaults to Pkcs7Padding already
break;
case "TBCPADDING":
padding = new TbcPadding();
break;
case "WITHCTS":
cts = true;
break;
case "X9.23PADDING":
case "X923PADDING":
padding = new X923Padding();
break;
case "ZEROBYTEPADDING":
padding = new ZeroBytePadding();
break;
default:
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
}
string mode = "";
if (parts.Length > 1)
{
mode = parts[1];
int di = GetDigitIndex(mode);
string modeName = di >= 0 ? mode.Substring(0, di) : mode;
switch (modeName)
{
case "":
case "ECB":
case "NONE":
break;
case "CBC":
blockCipher = new CbcBlockCipher(blockCipher);
break;
case "CCM":
aeadBlockCipher = new CcmBlockCipher(blockCipher);
break;
case "CFB":
{
int bits = (di < 0)
? 8 * blockCipher.GetBlockSize()
: int.Parse(mode.Substring(di));
blockCipher = new CfbBlockCipher(blockCipher, bits);
break;
}
case "CTR":
blockCipher = new SicBlockCipher(blockCipher);
break;
case "CTS":
cts = true;
blockCipher = new CbcBlockCipher(blockCipher);
break;
case "EAX":
aeadBlockCipher = new EaxBlockCipher(blockCipher);
break;
case "GCM":
aeadBlockCipher = new GcmBlockCipher(blockCipher);
break;
case "GOFB":
blockCipher = new GOfbBlockCipher(blockCipher);
break;
case "OFB":
{
int bits = (di < 0)
? 8 * blockCipher.GetBlockSize()
: int.Parse(mode.Substring(di));
blockCipher = new OfbBlockCipher(blockCipher, bits);
break;
}
case "OPENPGPCFB":
blockCipher = new OpenPgpCfbBlockCipher(blockCipher);
break;
case "SIC":
if (blockCipher.GetBlockSize() < 16)
{
throw new ArgumentException("Warning: SIC-Mode can become a twotime-pad if the blocksize of the cipher is too small. Use a cipher with a block size of at least 128 bits (e.g. AES)");
}
blockCipher = new SicBlockCipher(blockCipher);
break;
default:
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
}
if (aeadBlockCipher != null)
{
if (cts)
{
throw new SecurityUtilityException("CTS mode not valid for AEAD ciphers.");
}
if (padded && parts.Length > 1 && parts[2] != "")
{
throw new SecurityUtilityException("Bad padding specified for AEAD cipher.");
}
return(new BufferedAeadBlockCipher(aeadBlockCipher));
}
if (blockCipher != null)
{
if (cts)
{
return(new CtsBlockCipher(blockCipher));
}
if (!padded || blockCipher.IsPartialBlockOkay)
{
return(new BufferedBlockCipher(blockCipher));
}
if (padding != null)
{
return(new PaddedBufferedBlockCipher(blockCipher, padding));
}
return(new PaddedBufferedBlockCipher(blockCipher));
}
if (asymBlockCipher != null)
{
return(new BufferedAsymmetricBlockCipher(asymBlockCipher));
}
throw new SecurityUtilityException("Cipher " + algorithm + " not recognised.");
}
private object ReadValue(BinaryReader br, Type type, bool encrypted)
{
if (type == typeof(int))
{
return(br.ReadInt32());
}
else if (type == typeof(double))
{
return(br.ReadDouble());
}
else if (type == typeof(bool))
{
return(br.ReadBoolean());
}
else if (type == typeof(string))
{
if (!encrypted)
{
return(br.ReadString());
}
byte size = br.ReadByte();
byte[] data = RC4Engine.Decrypt(br.ReadBytes(size));
return(Encoding.ASCII.GetString(data));
}
else if (type == typeof(byte[]))
{
return(br.ReadBytes(br.ReadInt32()));
}
else if (type.IsEnum)
{
Type t = Enum.GetUnderlyingType(type);
if (t == typeof(byte))
{
return(br.ReadByte());
}
else if (t == typeof(short))
{
return(br.ReadInt16());
}
else if (t == typeof(int))
{
return(br.ReadInt32());
}
else if (t == typeof(long))
{
return(br.ReadInt64());
}
else
{
MessageBox.Show("Unable to read this enum type! Type: " + t.ToString());
}
}
else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(ISettingList <>))
{
object settingList = Activator.CreateInstance(type, new object[] { });
settingList.GetType().GetMethod("Read").Invoke(settingList, new object[] { br });
return(settingList);
}
else
{
MessageBox.Show("Cannot read type " + type.ToString());
}
return(null);
}
static void Main(string[] args)
{
byte[] key = ComputeTestKey();
byte[] testData = NewTestData();
byte[] jackpozData = testData.ToArray();
byte[] outputBufferBouncy = new byte[1024];
byte[] outputBufferJackpoz = new byte[1024];
JackpozARC4 arc4 = new JackpozARC4(key);
RC4CryptoServiceProvider myRc4 = new RC4CryptoServiceProvider(key, true);
RC4Engine bouncyRC4 = new RC4Engine();
bouncyRC4.Init(true, new KeyParameter(key));
byte[] sameBuffer = jackpozData.ToArray();
byte[] myRC4Buffer = jackpozData.ToArray();
bouncyRC4.ProcessBytes(testData, 0, testData.Length, outputBufferBouncy, 0);
arc4.Process(sameBuffer, sameBuffer, 0, sameBuffer.Length);
myRc4.ProcessBytes(myRC4Buffer, 0, myRC4Buffer.Length, myRC4Buffer, 0);
Console.WriteLine(jackpozData.Length);
for (int i = 0; i < jackpozData.Length; i++)
{
if (sameBuffer[i] != outputBufferBouncy[i])
{
Console.WriteLine($"Failed at index: {i} with Value Jackpoz: {sameBuffer[i]} vs Bouncy: {outputBufferBouncy[i]}");
Console.ReadKey();
}
if (myRC4Buffer[i] != outputBufferBouncy[i])
{
Console.WriteLine($"Failed at index: {i} with Value MyBuffer: {myRC4Buffer[i]} vs Jackpoz: {sameBuffer[i]}");
Console.ReadKey();
}
}
Console.WriteLine("Finished parity test.");
Stopwatch bouncyWatch = new Stopwatch();
bouncyWatch.Start();
for (int i = 0; i < 1000000; i++)
{
bouncyRC4.ProcessBytes(testData, 0, testData.Length, outputBufferBouncy, 0);
}
bouncyWatch.Stop();
GC.Collect();
Console.WriteLine($"Bouncy perf: {bouncyWatch.ElapsedMilliseconds}");
Stopwatch jackpozWatch = new Stopwatch();
jackpozWatch.Start();
for (int i = 0; i < 1000000; i++)
{
arc4.Process(jackpozData, outputBufferJackpoz, 0, jackpozData.Length);
}
jackpozWatch.Stop();
GC.Collect();
Console.WriteLine($"Jackpoz perf: {jackpozWatch.ElapsedMilliseconds}");
Console.ReadKey();
}
public static object CreateContentCipher(bool forEncryption, ICipherParameters encKey,
AlgorithmIdentifier encryptionAlgID)
{
DerObjectIdentifier encAlg = encryptionAlgID.Algorithm;
if (encAlg.Equals(PkcsObjectIdentifiers.rc4))
{
IStreamCipher cipher = new RC4Engine();
cipher.Init(forEncryption, encKey);
return(cipher);
}
else
{
BufferedBlockCipher cipher = CreateCipher(encryptionAlgID.Algorithm);
Asn1Object sParams = encryptionAlgID.Parameters.ToAsn1Object();
if (sParams != null && !(sParams is DerNull))
{
if (encAlg.Equals(PkcsObjectIdentifiers.DesEde3Cbc) ||
encAlg.Equals(AlgorithmIdentifierFactory.IDEA_CBC) ||
encAlg.Equals(NistObjectIdentifiers.IdAes128Cbc) ||
encAlg.Equals(NistObjectIdentifiers.IdAes192Cbc) ||
encAlg.Equals(NistObjectIdentifiers.IdAes256Cbc) ||
encAlg.Equals(NttObjectIdentifiers.IdCamellia128Cbc) ||
encAlg.Equals(NttObjectIdentifiers.IdCamellia192Cbc) ||
encAlg.Equals(NttObjectIdentifiers.IdCamellia256Cbc) ||
encAlg.Equals(KisaObjectIdentifiers.IdSeedCbc) ||
encAlg.Equals(OiwObjectIdentifiers.DesCbc))
{
cipher.Init(forEncryption, new ParametersWithIV(encKey,
Asn1OctetString.GetInstance(sParams).GetOctets()));
}
else if (encAlg.Equals(AlgorithmIdentifierFactory.CAST5_CBC))
{
Cast5CbcParameters cbcParams = Cast5CbcParameters.GetInstance(sParams);
cipher.Init(forEncryption, new ParametersWithIV(encKey, cbcParams.GetIV()));
}
else if (encAlg.Equals(PkcsObjectIdentifiers.RC2Cbc))
{
RC2CbcParameter cbcParams = RC2CbcParameter.GetInstance(sParams);
cipher.Init(forEncryption, new ParametersWithIV(new RC2Parameters(((KeyParameter)encKey).GetKey(), rc2Ekb[cbcParams.RC2ParameterVersion.IntValue]), cbcParams.GetIV()));
}
else
{
throw new InvalidOperationException("cannot match parameters");
}
}
else
{
if (encAlg.Equals(PkcsObjectIdentifiers.DesEde3Cbc) ||
encAlg.Equals(AlgorithmIdentifierFactory.IDEA_CBC) ||
encAlg.Equals(AlgorithmIdentifierFactory.CAST5_CBC))
{
cipher.Init(forEncryption, new ParametersWithIV(encKey, new byte[8]));
}
else
{
cipher.Init(forEncryption, encKey);
}
}
return(cipher);
}
}
/// <summary>
///
/// </summary>
/// <param name="hexRid"></param>
/// <param name="hashedBootKey"></param>
/// <param name="lmntpassword"></param>
/// <param name="isLmHash"></param>
/// <param name="userAccount"></param>
/// <returns></returns>
private bool DecryptHash(string hexRid,
byte[] hashedBootKey,
string lmntpassword,
bool isLmHash,
UserAccount userAccount)
{
try
{
userAccount.Rid = Int32.Parse(hexRid, System.Globalization.NumberStyles.HexNumber);
byte[] tempBootKey = new byte[16];
Buffer.BlockCopy(hashedBootKey, 0, tempBootKey, 0, 16);
List <byte> data = new List <byte>();
data.AddRange(tempBootKey.ToArray());
data.AddRange(MiscUtil.Conversion.EndianBitConverter.Little.GetBytes(Int32.Parse(hexRid, System.Globalization.NumberStyles.HexNumber)));
data.AddRange(Encoding.ASCII.GetBytes(lmntpassword));
byte[] md5 = MD5.Create().ComputeHash(data.ToArray());
//PrintHex(md5);
byte[] encOutput = new byte[16];
RC4Engine rc4Engine = new RC4Engine();
if (isLmHash == true)
{
rc4Engine.Init(true, new KeyParameter(md5));
rc4Engine.ProcessBytes(userAccount.EncLmHash, 0, 16, encOutput, 0);
}
else
{
rc4Engine.Init(true, new KeyParameter(md5));
rc4Engine.ProcessBytes(userAccount.EncNtHash, 0, 16, encOutput, 0);
}
//PrintHex(encOutput);
byte[] hashBytes1 = new byte[8];
byte[] hashBytes2 = new byte[8];
Buffer.BlockCopy(encOutput, 0, hashBytes1, 0, 8);
Buffer.BlockCopy(encOutput, 8, hashBytes2, 0, 8);
List <int> key1Temp = new List <int>();
List <int> key2Temp = new List <int>();
this.SidToKey(hexRid, ref key1Temp, ref key2Temp);
DESCryptoServiceProvider cryptoProvider = new DESCryptoServiceProvider();
List <byte> key1 = new List <byte>();
foreach (int val in key1Temp)
{
key1.Add((byte)val);
}
List <byte> key2 = new List <byte>();
foreach (int val in key2Temp)
{
key2.Add((byte)val);
}
cryptoProvider.Padding = PaddingMode.None;
cryptoProvider.Mode = CipherMode.ECB;
ICryptoTransform transform = cryptoProvider.CreateDecryptor(key1.ToArray(), new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 });
MemoryStream memoryStream = new MemoryStream(hashBytes1);
CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Read);
byte[] plainTextBytes = new byte[hashBytes1.Length];
int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
PrintHex("HASH:", plainTextBytes);
if (isLmHash == true)
{
userAccount.LmHash = Text.ConvertByteArrayToHexString(plainTextBytes);
}
else
{
userAccount.NtHash = Text.ConvertByteArrayToHexString(plainTextBytes);
}
//PrintHex(plainTextBytes);
cryptoProvider.Padding = PaddingMode.None;
cryptoProvider.Mode = CipherMode.ECB;
transform = cryptoProvider.CreateDecryptor(key2.ToArray(), new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 });
memoryStream = new MemoryStream(hashBytes2);
cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Read);
plainTextBytes = new byte[hashBytes2.Length];
decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length);
if (isLmHash == true)
{
userAccount.LmHash += Text.ConvertByteArrayToHexString(plainTextBytes);
}
else
{
userAccount.NtHash += Text.ConvertByteArrayToHexString(plainTextBytes);
}
//PrintHex(plainTextBytes);
return(true);
}
catch (Exception ex)
{
this.OnError("An error occured whilst decrypting the user hash");
Misc.WriteToEventLog(Application.ProductName, "An error occured whilst decrypting the user hash: " + ex.Message, EventLogEntryType.Error);
return(false);
}
}
