// hashing overloads for different inputs
// string input, byte input, with and without password
// needs to return byte or string depending on input
// if string input => string output
// if byte input => byte output
public string Hash(HashType type, string input)
{
switch (type)
{
case HashType.Md5Hash:
Md5Hash md5 = new Md5Hash();
return(md5.Hash(input));
case HashType.Sha1Hash:
Sha1Hash sha1 = new Sha1Hash();
return(sha1.Hash(input));
case HashType.Sha2Hash:
Sha2Hash sha2 = new Sha2Hash();
return(sha2.Hash(input));
case HashType.Sha3Hash:
Sha3Hash sha3 = new Sha3Hash();
return(sha3.Hash(input));
case HashType.Sha5Hash:
Sha5Hash sha5 = new Sha5Hash();
return(sha5.Hash(input));
default:
return("Cannot hash with this input");
}
}
private void WriteConnectionHeader(
BinaryWriter writer,
Sha1Hash infoHash,
PeerId localPeerId)
{
// Length of protocol string
writer.Write((byte)BitTorrentProtocol.Length);
// Protocol
writer.Write(BitTorrentProtocol.ToCharArray());
// Reserved bytes
var reservedBytes = new byte[BitTorrentProtocolReservedBytes];
var prepareHandshakeContext = new PrepareHandshakeContext(reservedBytes);
foreach (var module in modules.Modules)
{
module.OnPrepareHandshake(prepareHandshakeContext);
}
writer.Write(prepareHandshakeContext.ReservedBytes);
// Info hash
writer.Write(infoHash.Value);
// Peer ID
writer.Write(localPeerId.Value.ToArray());
writer.Flush();
}
public byte[] Hash(HashType type, byte[] input)
{
switch (type)
{
case HashType.Md5Hash:
Md5Hash md5 = new Md5Hash();
return(md5.Hash(input));
case HashType.Sha1Hash:
Sha1Hash sha1 = new Sha1Hash();
return(sha1.Hash(input));
case HashType.Sha2Hash:
Sha2Hash sha2 = new Sha2Hash();
return(sha2.Hash(input));
case HashType.Sha3Hash:
Sha3Hash sha3 = new Sha3Hash();
return(sha3.Hash(input));
case HashType.Sha5Hash:
Sha5Hash sha5 = new Sha5Hash();
return(sha5.Hash(input));
default:
return(null);
}
}
/// <summary>
/// Create a new game
/// </summary>
/// <param name="game"></param>
/// <returns></returns>
public GameModel CreateGame(GameModel game)
{
if (game == null || !IsValid(game))
{
throw HttpResponseExceptionHelper.Create("Invalid format for specified new Game",
HttpStatusCode.BadRequest);
}
var username = UserToken.Username;
game.HostHashId = UserToken.UserId;
game.HashId = Sha1Hash.GetSha1HashData(username + game.Name);
// Add host to participants
game.CurrentPlayerCount = 1;
game.ParticipantsHashId.Add(UserToken.UserId);
game.State = EnumsModel.GameState.Waiting;
// insert in gameList
lock (LockObj)
{
GameList.Add(game);
return(ToPublic(game));
}
}
public void HonorsAbortRequest()
{
string pw = TestValues.GetPw(5);
int eventCounter = 0;
var logic = new LogicImplementation();
logic.CollisionFound += (p) => { };
logic.ProgressChanged += (c, l) => { eventCounter++; };
var startTime = DateTime.Now;
try
{
logic.StartSearchCollisionsTask(Sha1Hash.CalculateFromString(pw));
startTime = DateTime.Now;
while ((eventCounter == 0) && ((DateTime.Now - startTime).TotalMilliseconds < 500))
{
Thread.Sleep(5);
}
}
catch (Exception ex)
{
Assert.Fail($"Logic - \'StartSearchCollisionsTask\' method throws an exception: {ex.GetType().ToString()} - {ex.Message} ");
}
logic.AbortSearch();
eventCounter = 0;
startTime = DateTime.Now;
while ((eventCounter <= 1) && ((DateTime.Now - startTime).TotalMilliseconds < 200))
{
Thread.Sleep(5);
}
Assert.IsTrue((eventCounter <= 1), $"Logic - AbortSearch does not stop background Task.");
}
public static void Main(string [] args)
{
var parser = new CommandLineParser.CommandLineParser();
var algorithm = new EnumeratedValueArgument <string> (
'a',
"algorithm",
"available algorithms for computing hash, default to SHA1",
new [] { Md2Hash.ALGORITHM_NAME,
Md5Hash.ALGORITHM_NAME,
Sha1Hash.ALGORITHM_NAME,
Sha256Hash.ALGORITHM_NAME,
Sha384Hash.ALGORITHM_NAME,
Sha512Hash.ALGORITHM_NAME });
algorithm.DefaultValue = Sha1Hash.ALGORITHM_NAME;
var source = new ValueArgument <string> (
's',
"source",
"source to compute hash");
source.Optional = false;
var salt = new ValueArgument <string> (
't',
"salt",
"salt for computing hash");
var iterations = new ValueArgument <int> (
'i',
"iterations",
"iterations when compute hash");
iterations.DefaultValue = 1;
parser.Arguments.AddRange(
new Argument [] { algorithm, source, salt, iterations });
parser.ParseCommandLine(args);
if (!source.Parsed || string.IsNullOrEmpty(source.Value))
{
parser.ShowUsage();
return;
}
SimpleHash hash = null;
if (algorithm.Parsed)
{
hash = new SimpleHash(algorithm.Value, source.Value, salt.Value, iterations.Value);
}
if (hash == null)
{
hash = new Sha1Hash(source.Value, salt.Value, iterations.Value);
}
Console.WriteLine("algorithms :" + hash.AlgorithmName);
Console.WriteLine("source :" + source.Value);
Console.WriteLine("salt :" + salt.Value);
Console.WriteLine("iterations :" + iterations.Value);
Console.WriteLine("hash(hex) :" + hash.ToHex());
Console.WriteLine("hash(base64):" + hash.ToBase64());
}
public void DetectsCollision()
{
string pw = TestValues.GetPw(2);
string foundPw = string.Empty;
var logic = new LogicImplementation();
logic.CollisionFound += (p) => { foundPw = p; };
logic.ProgressChanged += (c, l) => { };
try
{
logic.StartSearchCollisionsTask(Sha1Hash.CalculateFromString(pw));
var startTime = DateTime.Now;
while ((foundPw == string.Empty) && ((DateTime.Now - startTime).TotalMilliseconds < 1000))
{
Thread.Sleep(5);
}
}
catch (Exception ex)
{
Assert.Fail($"Logic - \'StartSearchCollisionsTask\' method throws an exception: {ex.GetType().ToString()} - {ex.Message} ");
}
logic.AbortSearch();
Assert.IsFalse((foundPw == string.Empty), $"Logic - does not return a collision through its 'CollisionFound' event.");
Assert.IsTrue((pw == foundPw), $"Logic - returns wrong value for a collision: \'{foundPw}\', expected: \'{pw}\'.");
}
public void HonorsReportInterval()
{
int testInterval = 20;
string pw = TestValues.GetPw(5);
ulong pwCount = 0;
var intervals = new List <int>();
var previousTime = DateTime.Now;
var logic = new LogicImplementation();
var cancelSource = new CancellationTokenSource();
var cancelToken = cancelSource.Token;
var progress = new Progress <ulong>((count) =>
{
pwCount = count;
DateTime t = DateTime.Now;
intervals.Add((int)(t - previousTime).TotalMilliseconds);
previousTime = t;
});
var collisionFound = new Progress <string>((result) => { });
logic.ReportInterval = testInterval;
var task = Task.Run(() => { logic.SearchCollisions(Sha1Hash.CalculateFromString(pw), progress, collisionFound, cancelToken); });
var startTime = DateTime.Now;
while ((intervals.Count() < 4) && ((DateTime.Now - startTime).TotalMilliseconds < 500))
{
Thread.Sleep(5);
}
Assert.IsFalse((intervals.Count() == 0), $"SearchCollisions - does not report progress through its 'progress' object.");
cancelSource.Cancel();
intervals.RemoveAt(0);
int interval = (intervals[0] + intervals[1] + intervals[2]) / 3;
Assert.IsTrue((Math.Abs(testInterval - interval) < 20),
$"SearchCollisions - does not report progress at requested interval of {testInterval}ms, was {interval}ms.");
}
// HandleLogonProof stuff
public static BigInteger Getu(BigInteger A, BigInteger B)
{
Sha1Hash h = new Sha1Hash();
h.Update(A);
return(new BigInteger(h.Final(B)));
}
public void Setup()
{
writtenData = new List <Tuple <long, byte[]> >();
Sha1Hash hash;
using (var sha1 = SHA1.Create())
hash = new Sha1Hash(sha1.ComputeHash(Enumerable.Repeat((byte)0, 50).ToArray()));
var metainfo = new Metainfo("test",
Sha1Hash.Empty,
new[]
{
new ContainedFile("File1.txt", 100),
},
new[]
{
new Piece(0, 50, hash),
new Piece(50, 50, hash),
},
new IEnumerable <Uri> [0],
new byte[0]);
var baseHandler = new Mock <IBlockDataHandler>();
baseHandler.Setup(x => x.Metainfo)
.Returns(metainfo);
baseHandler.Setup(x => x.WriteBlockData(It.IsAny <long>(),
It.IsAny <byte[]>()))
.Callback <long, byte[]>((offset, data) => writtenData.Add(Tuple.Create(offset, data)));
pieceChecker = new PieceCheckerHandler(baseHandler.Object);
}
public BigInteger GetM(string Username, BigInteger s, BigInteger A, BigInteger B, BigInteger K)
{
Sha1Hash sha;
sha = new Sha1Hash();
byte[] hash = sha.Final(N);
sha = new Sha1Hash();
byte[] ghash = sha.Final(g);
for (int i = 0; i < 20; ++i)
{
hash[i] ^= ghash[i];
}
// TODO: do t2 and t4 need to be BigInts? Could we just use the byte[]?
BigInteger t3 = new BigInteger(hash);
sha = new Sha1Hash();
sha.Update(Username);
BigInteger t4 = new BigInteger(sha.Final());
sha = new Sha1Hash();
sha.Update(t3);
sha.Update(t4);
sha.Update(s);
sha.Update(A);
sha.Update(B);
return(new BigInteger(sha.Final(K)));
}
public void Sha1Hash_GetHash_Null_3()
{
IHash hashAlgo = new Sha1Hash();
Action action = () => hashAlgo.GetHash(null as FileInfo);
action.Should().Throw <ArgumentNullException>();
}
public void Sha1Hash_GetHash_Empty()
{
IHash hashAlgo = new Sha1Hash();
Action action = () => hashAlgo.GetHash(string.Empty);
action.Should().Throw <ArgumentNullException>();
}
public AnnounceRequest(PeerId peerId,
long remaining,
Sha1Hash infoHash)
{
PeerId = peerId;
Remaining = remaining;
InfoHash = infoHash;
}
public void StartSearchCollisionsTask(Sha1Hash hash)
{
IProgress <string> foundCollision = new Progress <string>((collision) => { CollisionFound?.Invoke(collision); });
IProgress <ulong> changedProgress = new Progress <ulong>((aantalPasswords) => { ProgressChanged?.Invoke(aantalPasswords, lengthTestedPassword); });
cancelSource = new CancellationTokenSource();
Task.Run(() => { SearchCollisions(hash, changedProgress, foundCollision, cancelSource.Token); });
}
public static byte[] GetLogonHash(string Username, string Password)
{
Sha1Hash h = new Sha1Hash();
string sI = String.Format("{0}:{1}", Username, Password.ToUpper());
h.Update(sI);
return(h.Final());
}
public static BigInteger Getx(BigInteger Salt, byte[] LogonHash)
{
Sha1Hash h = new Sha1Hash();
h.Update(Salt);
h.Update(LogonHash);
return(new BigInteger(h.Final()));
}
public static byte[] GetM2(BigInteger A, BigInteger M, BigInteger K)
{
Sha1Hash h = new Sha1Hash();
h.Update(A);
h.Update(M);
return(h.Final(K));
}
public void Sha1Hash_GetHash_Valid_2()
{
IHash hashAlgo = new Sha1Hash();
HashResult hashResult = hashAlgo.GetHash(Data.ExpectedHashFilePath);
hashResult.Algorithm.Should().Be(Hashing.ExpectedSha1Algorithm);
hashResult.Value.Should().Be(Hashing.ExpectedSha1Hash);
}
private Metainfo MockMetaInfo()
{
var fakeHash = new Sha1Hash(new byte[20]);
var fakePieces = new List <Piece>
{
new Piece(0, 100, fakeHash),
};
return(new Metainfo("Mock", fakeHash, new List <ContainedFile>(), fakePieces, new List <List <Uri> >(), new List <byte>()));
}
private void buttonSearchCollisions_Click(object sender, EventArgs e)
{
textBoxLength.Clear();
textBoxCollision.Clear();
textBoxCount.Clear();
var hashPassword = Sha1Hash.GetFromHex(passwordHash);
logicImpl.StartSearchCollisionsTask(hashPassword);
}
public void Sha1Hash_GetHash_Valid_1()
{
IHash hashAlgo = new Sha1Hash();
using FileStream fileStream = new(Data.ExpectedHashFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
HashResult hashResult = hashAlgo.GetHash(fileStream);
hashResult.Algorithm.Should().Be(Hashing.ExpectedSha1Algorithm);
hashResult.Value.Should().Be(Hashing.ExpectedSha1Hash);
}
public bool Compare(Sha1Hash hashX, Sha1Hash hashY)
{
bool result = false;
if (hashX != null && hashY != null)
{
result = Compare(hashX.Value, hashY.Value);
}
return(result);
}
public AnnounceRequest(PeerId peerId,
long remaining,
long downloaded,
long uploaded,
Sha1Hash infoHash)
{
PeerId = peerId;
Remaining = remaining;
Downloaded = downloaded;
Uploaded = uploaded;
InfoHash = infoHash;
}
private void buttonCalculateHash_Click(object sender, EventArgs e)
{
string password = textBoxPassword.Text;
password = password.ToUpper();
passwordHash = Sha1Hash.CalculateFromString(password).ToString();
textBoxHash.Text = passwordHash;
textBoxPassword.Text = password;
buttonAbort.Enabled = true;
buttonSearchCollisions.Enabled = true;
}
public void CanStartSearchAfterAbort()
{
// start and abort a search.
string pw = TestValues.GetPw(5);
string foundPw = string.Empty;
int eventCounter = 0;
var logic = new LogicImplementation();
logic.CollisionFound += (p) => { foundPw = p; };
logic.ProgressChanged += (c, l) => { eventCounter++; };
var startTime = DateTime.Now;
try
{
logic.StartSearchCollisionsTask(Sha1Hash.CalculateFromString(pw));
startTime = DateTime.Now;
while ((eventCounter == 0) && ((DateTime.Now - startTime).TotalMilliseconds < 500))
{
Thread.Sleep(5);
}
}
catch (Exception ex)
{
Assert.Fail($"Logic - \'StartSearchCollisionsTask\' method throws an exception: {ex.GetType().ToString()} - {ex.Message} ");
}
logic.AbortSearch();
eventCounter = 0;
startTime = DateTime.Now;
while ((eventCounter <= 1) && ((DateTime.Now - startTime).TotalMilliseconds < 200))
{
Thread.Sleep(5);
}
Assert.IsTrue((eventCounter <= 1), $"Logic - AbortSearch does not stop background Task.");
// and start a second one
pw = TestValues.GetPw(2);
foundPw = string.Empty;
try
{
logic.StartSearchCollisionsTask(Sha1Hash.CalculateFromString(pw));
startTime = DateTime.Now;
while ((foundPw == string.Empty) && ((DateTime.Now - startTime).TotalMilliseconds < 1000))
{
Thread.Sleep(5);
}
}
catch (Exception ex)
{
Assert.Fail($"Logic - \'StartSearchCollisionsTask\' method throws an exception when started after an abort request: {ex.GetType().ToString()} - {ex.Message} ");
}
Assert.IsFalse((foundPw == string.Empty), $"Logic - does not return a collision when started after an abort request.");
logic.AbortSearch();
}
private void SaveResumeDataAlert(Core.save_resume_data_alert a)
{
Interlocked.MemoryBarrier();
TorrentHandle h = null;
BinaryWriter bw = null;
FileStream fs = null;
try
{
h = a.handle;
using (TorrentInfo ti = h.torrent_file())
using (Sha1Hash hash = h.info_hash())
{
log.Debug("processing {0}", ti.name());
string newfilePath = ("./Fastresume/" + hash.ToString() + ".fastresume");
var data = Core.Util.bencode(a.resume_data);
fs = new FileStream(newfilePath, FileMode.OpenOrCreate);
bw = new BinaryWriter(fs);
bw.Write(data);
bw.Close();
log.Debug("done {0}", ti.name());
}
//log.Debug(" for {0}", h.torrent_file().name());
//string newfilePath = ("./Fastresume/" + h.info_hash().ToString() + ".fastresume");
//var data = Core.Util.bencode(a.resume_data);
//fs = new FileStream(newfilePath, FileMode.OpenOrCreate);
//bw = new BinaryWriter(fs);
//bw.Write(data);
//bw.Close();
}
finally
{
if (!ReferenceEquals(null, h))
{
h.Dispose();
}
if (!ReferenceEquals(null, bw))
{
bw.Dispose();
}
if (!ReferenceEquals(null, fs))
{
fs.Dispose();
}
}
Interlocked.Decrement(ref outstanding_resume_data);
if (outstanding_resume_data == 0 && no_more_resume)
{
no_more_data.Set();
}
}
void OnBCalcSha1Click(object sender, EventArgs e)
{
try
{
ShowStatusMessage(Str.cHashCalculating);
if (_Sha1Main == null)
{
_Sha1Main = new Sha1Alg();
}
//получаем количество значимых бит от пользователя и если оно корректно устанавливаем его,
//иначе - работаем с количеством бит по умолчанию
int userHashBitCount;
if (int.TryParse(tbHashBitCount.Text, out userHashBitCount) &&
userHashBitCount >= cMinHashBitCount && userHashBitCount <= cMaxHashBitCount)
{
HashBitCount = userHashBitCount;
}
else
{
tbHashBitCount.Text = HashBitCount.ToString();
}
Stopwatch hashSW = new Stopwatch();
hashSW.Start(); //запускаем замер времени выполнения
_MainHash = _Sha1Main.GetHash(tbInputText.Text); //вычисляем хеш от содержимого текстбокса
hashSW.Stop(); //останавливаем, независимо от результата
if (_MainHash != null && !String.IsNullOrEmpty(_MainHash.Text))
{
lSha1Hash.Text = "0x" + _MainHash.Text;
lTruncSha1Hash.Text = "0x" + _Sha1Main.GetTruncateHash(_MainHash.Value).Text;
lSha1Time.Text = hashSW.Elapsed.ToString();
_MainText = tbInputText.Text;
_Sha1Calculated = true; //указываем что в _Sha1Main посчитанный хеш и можно искать коллизии
ShowStatusMessage(Str.cHashCalcEnd);
}
else
{
ShowStatusMessage(Str.cCantCalcHash, true);
}
}
catch (Exception ex)
{
ShowStatusMessage(Str.cExceptionHappened + ex.Message, true);
}
}
public void DoAuthSession()
{
try
{
PacketOut packet = new PacketOut(WorldServerOpCode.CMSG_AUTH_SESSION);
Sha1Hash sha = new Sha1Hash();
sha.Update(mUsername);
sha.Update(new byte[4]); // t
sha.Update(ClientSeed);
sha.Update(ServerSeed);
sha.Update(mKey);
byte[] Digest = sha.Final();
packet.Write((UInt32)Config.Version.build);
packet.Write((UInt32)0);
packet.Write(mUsername);
packet.Write((UInt32)0);
packet.Write(ClientSeed);
packet.Write((UInt64)0);
packet.Write(Digest);
bool WantToCrash = false;
if (WantToCrash)
{
byte[] addons = { (byte)0x00 };
byte[] buffer2 = mClient.Shared.Compression.Compress(addons);
UInt32 Size = (UInt32)addons.Length;
packet.Write(Size);
packet.Write(buffer2);
}
else
{
byte[] addon_data = { 0x56, 0x01, 0x00, 0x00, 0x78, 0x9c, 0x75, 0xcc, 0xbd, 0x0e, 0xc2, 0x30, 0x0c, 0x04, 0xe0, 0xf2, 0x1e, 0xbc, 0x0c, 0x61, 0x40, 0x95, 0xc8, 0x42, 0xc3, 0x8c, 0x4c, 0xe2, 0x22, 0x0b, 0xc7, 0xa9, 0x8c, 0xcb, 0x4f, 0x9f, 0x1e, 0x16, 0x24, 0x06, 0x73, 0xeb, 0x77, 0x77, 0x81, 0x69, 0x59, 0x40, 0xcb, 0x69, 0x33, 0x67, 0xa3, 0x26, 0xc7, 0xbe, 0x5b, 0xd5, 0xc7, 0x7a, 0xdf, 0x7d, 0x12, 0xbe, 0x16, 0xc0, 0x8c, 0x71, 0x24, 0xe4, 0x12, 0x49, 0xa8, 0xc2, 0xe4, 0x95, 0x48, 0x0a, 0xc9, 0xc5, 0x3d, 0xd8, 0xb6, 0x7a, 0x06, 0x4b, 0xf8, 0x34, 0x0f, 0x15, 0x46, 0x73, 0x67, 0xbb, 0x38, 0xcc, 0x7a, 0xc7, 0x97, 0x8b, 0xbd, 0xdc, 0x26, 0xcc, 0xfe, 0x30, 0x42, 0xd6, 0xe6, 0xca, 0x01, 0xa8, 0xb8, 0x90, 0x80, 0x51, 0xfc, 0xb7, 0xa4, 0x50, 0x70, 0xb8, 0x12, 0xf3, 0x3f, 0x26, 0x41, 0xfd, 0xb5, 0x37, 0x90, 0x19, 0x66, 0x8f };
packet.Write(addon_data);
}
Send(packet);
mCrypt = new PacketCrypt(mKey);
mCrypt.Init();
}
catch (Exception e)
{
Log.WriteLine(LogType.Error, e.StackTrace);
}
}
public Sha1Hash GetHash(string text, Encoding enc)
{
Sha1Hash result = new Sha1Hash();
byte[] buffer = enc.GetBytes(text); //преобразуем переданный текст в набор байт с учетом кодировки
InitializeState(); //задаем начальные значения
HashData(buffer, 0, buffer.Length); //вычисляем все блоки кроме последнего
result.Value = EndHash(); //вычисляем последний блок и фиксируем результат
result.ByteCount = result.Value.Length;
return(result);
}
