public static string Md5(string input)
{
var data = System.Text.Encoding.UTF8.GetBytes(input);
MD5Digest hash = new MD5Digest();
hash.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[hash.GetDigestSize()];
hash.DoFinal(result, 0);
return Hex.ToHexString(result);
}
public static String MD5(String toHashMD5)
{
MD5Digest digest = new MD5Digest();
byte[] scratch = new byte[digest.GetDigestSize()];
digest.BlockUpdate(UTF8Encoding.UTF8.GetBytes(toHashMD5), 0, UTF8Encoding.UTF8.GetByteCount(toHashMD5));
digest.DoFinal(scratch, 0);
string hex = BitConverter.ToString(scratch).ToLower();
return hex.Replace("-", "");
}
public static byte[] CalculateAnswerBytes(string key1, string key2, ArraySegment<byte> challenge)
{
byte[] result1Bytes = ParseKey(key1);
byte[] result2Bytes = ParseKey(key2);
var rawAnswer = new byte[16];
Array.Copy(result1Bytes, 0, rawAnswer, 0, 4);
Array.Copy(result2Bytes, 0, rawAnswer, 4, 4);
Array.Copy(challenge.Array, challenge.Offset, rawAnswer, 8, 8);
#if PORTABLE
IDigest hash = new MD5Digest();
byte[] result = new byte[hash.GetDigestSize()];
hash.BlockUpdate(rawAnswer, 0, rawAnswer.Length);
hash.DoFinal(result, 0);
return result;
//// Convert the message string to binary data.
//IBuffer buffUtf8Msg = CryptographicBuffer.CreateFromByteArray(rawAnswer);
//// Create a HashAlgorithmProvider object.
//HashAlgorithmProvider objAlgProv = HashAlgorithmProvider.OpenAlgorithm(HashAlgorithmNames.Md5);
//// Demonstrate how to retrieve the name of the hashing algorithm.
//String strAlgNameUsed = objAlgProv.AlgorithmName;
//// Hash the message.
//IBuffer buffHash = objAlgProv.HashData(buffUtf8Msg);
//// Verify that the hash length equals the length specified for the algorithm.
//if (buffHash.Length != objAlgProv.HashLength)
//{
// throw new Exception("There was an error creating the hash");
//}
//// Convert the hash to a string (for display).
//String strHashBase64 = CryptographicBuffer.EncodeToBase64String(buffHash);
//byte[] resultArray = new byte[buffHash.Length];
//CryptographicBuffer.CopyToByteArray(buffHash, out resultArray);
//return resultArray;
#else
return MD5.Create().ComputeHash(rawAnswer);
#endif
}
public static string MD5Hash(this IFile file)
{
using (var fileStream = file.OpenAsync(FileAccess.Read).Result)
{
var data = fileStream.ReadFully();
var md5 = new MD5Digest();
var md5Hash = new byte[md5.GetDigestSize()];
md5.BlockUpdate(data, 0, data.Length);
md5.DoFinal(md5Hash, 0);
md5.Reset();
return BitConverter.ToString(md5Hash).Replace("-", "").ToLower();
}
}
public static byte[] Digest(byte[] data, String algo)
{
if (algo == null)
{
throw new ArgumentNullException("El algoritmo de huella digital no puede ser nulo");
}
if (data == null)
{
throw new ArgumentNullException("Los datos no pueden ser nulos");
}
switch (algo)
{
/**
* ALGORITMOS DE HASING
*/
case AOSignConstants.SIGN_ALGORITHM_SHA1:
{
Sha1Digest dig = new Sha1Digest();
dig.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
return result;
}
case AOSignConstants.SIGN_ALGORITHM_SHA256:
{
Sha256Digest dig = new Sha256Digest();
dig.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
return result;
}
case AOSignConstants.SIGN_ALGORITHM_SHA384:
{
Sha384Digest dig = new Sha384Digest();
dig.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
return result;
}
case AOSignConstants.SIGN_ALGORITHM_SHA512:
{
Sha512Digest dig = new Sha512Digest();
dig.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
return result;
}
case AOSignConstants.SIGN_ALGORITHM_RIPEMD160:
{
RipeMD160Digest dig = new RipeMD160Digest();
dig.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
return result;
}
case AOSignConstants.SIGN_ALGORITHM_MD5:
{
MD5Digest dig = new MD5Digest();
dig.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
return result;
}
case AOSignConstants.SIGN_ALGORITHM_MD2:
{
MD2Digest dig = new MD2Digest();
dig.BlockUpdate(data, 0, data.Length);
byte[] result = new byte[dig.GetDigestSize()];
dig.DoFinal(result, 0);
return result;
}
default:
// You can use the default case.
throw new ArgumentNullException("El algoritmo no es reconocido");
}
throw new ArgumentNullException("Algoritmo de hash no soportado: " + algo);
}
public ITestResult Perform()
{
IDigest digest = new MD5Digest();
byte[] resBuf = new byte[digest.GetDigestSize()];
string resStr;
//
// test 1
//
digest.DoFinal(resBuf, 0);
resStr = Hex.ToHexString(resBuf);
if (!resVec1.Equals(resStr))
{
return new SimpleTestResult(false,
"MD5 failing standard vector test 1"
+ SimpleTest.NewLine
+ " expected: " + resVec1
+ SimpleTest.NewLine
+ " got : " + resStr);
}
//
// test 2
//
byte[] bytes = Hex.Decode(testVec2);
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(resBuf, 0);
resStr = Hex.ToHexString(resBuf);
if (!resVec2.Equals(resStr))
{
return new SimpleTestResult(false,
"MD5 failing standard vector test 2"
+ SimpleTest.NewLine
+ " expected: " + resVec2
+ SimpleTest.NewLine
+ " got : " + resStr);
}
//
// test 3
//
bytes = Hex.Decode(testVec3);
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(resBuf, 0);
resStr = Hex.ToHexString(resBuf);
if (!resVec3.Equals(resStr))
{
return new SimpleTestResult(false,
"MD5 failing standard vector test 3"
+ SimpleTest.NewLine
+ " expected: " + resVec3
+ SimpleTest.NewLine
+ " got : " + resStr);
}
//
// test 4
//
bytes = Hex.Decode(testVec4);
digest.BlockUpdate(bytes, 0, bytes.Length);
digest.DoFinal(resBuf, 0);
resStr = Hex.ToHexString(resBuf);
if (!resVec4.Equals(resStr))
{
return new SimpleTestResult(false,
"MD5 failing standard vector test 4"
+ SimpleTest.NewLine
+ " expected: " + resVec4
+ SimpleTest.NewLine
+ " got : " + resStr);
}
//
// test 5
//
bytes = Hex.Decode(testVec4);
digest.BlockUpdate(bytes, 0, bytes.Length/2);
// clone the IDigest
IDigest d = new MD5Digest((MD5Digest)digest);
digest.BlockUpdate(bytes, bytes.Length/2, bytes.Length - bytes.Length/2);
digest.DoFinal(resBuf, 0);
resStr = Hex.ToHexString(resBuf);
if (!resVec4.Equals(resStr))
{
return new SimpleTestResult(false,
"MD5 failing standard vector test 5"
+ SimpleTest.NewLine
+ " expected: " + resVec4
+ SimpleTest.NewLine
+ " got : " + resStr);
}
d.BlockUpdate(bytes, bytes.Length/2, bytes.Length - bytes.Length/2);
d.DoFinal(resBuf, 0);
resStr = Hex.ToHexString(resBuf);
if (!resVec4.Equals(resStr))
{
return new SimpleTestResult(false,
"MD5 failing standard vector test 5"
+ SimpleTest.NewLine
+ " expected: " + resVec4
+ SimpleTest.NewLine
+ " got : " + resStr);
}
return new SimpleTestResult(true, Name + ": Okay");
}
public void run()
{
AsymmetricCipherKeyPair aKeyPair = _keyGen.GenerateKeyPair();
IBasicAgreement aKeyAgreeBasic = AgreementUtilities.GetBasicAgreement("ECDH");
aKeyAgreeBasic.Init(aKeyPair.Private);
byte[] pubEnc = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(aKeyPair.Public).GetDerEncoded();
IPAddress ip=IPAddress.Parse("192.168.1.117");
IPEndPoint ipe = new IPEndPoint(ip, 8899);
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(ipe);
//byte[] bs = Encoding.ASCII.GetBytes("Windows Test");
socket.Send(pubEnc, pubEnc.Length, 0);
byte[] recvBytes = new byte[1024];
int bytes=socket.Receive(recvBytes, recvBytes.Length, 0);
socket.Close();
byte[] bPub = new byte[bytes];
for (int i = 0; i < bytes; i++)
{
bPub[i] = recvBytes[i];
}
ECPublicKeyParameters pubKey = (ECPublicKeyParameters)PublicKeyFactory.CreateKey(bPub);
BigInteger k = aKeyAgreeBasic.CalculateAgreement(pubKey);
byte[] keyBytes = k.ToByteArray();
//Console.WriteLine(keybytes.Length);
if (keyBytes.Length > 24)
{
byte[] fixedKeybytes = new byte[24];
for (int i = 0; i < 24; i++)
{
fixedKeybytes[i] = keyBytes[i + keyBytes.Length - 24];
}
keyBytes = fixedKeybytes;
}
Console.WriteLine(Hex.ToHexString(keyBytes));
IDigest digest = new MD5Digest();
digest.BlockUpdate(keyBytes, 0, keyBytes.Length);
byte[] idBytes = new byte[digest.GetDigestSize()];
digest.DoFinal(idBytes, 0);
_id = Hex.ToHexString(idBytes);
Console.WriteLine(_id);
_trivium = new Trivium();
_trivium.setKIV(keyBytes);
_trivium.initProcess();
}
public static byte[] HashMD5(string plainText)
{
// Create digest instance to compute our hash
var hash = new MD5Digest();
// Create a buffer large enough to store the computed hash
var resultBytes = new byte[hash.GetDigestSize()];
// Convert plain text string to bytes
var plainBytes = Encoding.UTF8.GetBytes(plainText);
// Process the bytes
hash.BlockUpdate(plainBytes, 0, plainBytes.Length);
// Process final output
hash.DoFinal(resultBytes, 0);
// Convert to string
return resultBytes;
}
