asyncCreator.py

import sys
import csv
import json
import string
import math
import requests
import threading
import random

import deathbycaptcha

word_array = ["","Karil","Kiler","K1ler","Kil3r","K1ll3r","Noob2","N3wb","Favor","Hand","Slack","Fad","Bruh","D34D","Paige","Larry","Th3","M4ny","P1ll","Junki3","L4b0r","P4rty","W1ldy","Fallen","xx","6969","Fun","B33F","DEADBEEF","Dad","Lob","Deb","Koh","Gary","Garry","G4ry","Jerry","J3rry","E4rth","Bearer","Guthan","Glien","Gnome","Sara","Domin","Guthix","Varack","Ride","Raider","Fallout","Flying","Machine","Dob","Rob","Bot","Life","L1f3","Otter","W4ter","Fire","Read","Gi4nt","Hilt","Conqr","Speer","Edge","Slay","Guide","lyf3","lyf3","4lyfe","Seal"]

#Posts captchas to DeathByCaptcha and information to Runescape
class Poster:
	def __init__(self,dbc_user,dbc_passw,datah):
		self.client = deathbycaptcha.HttpClient(dbc_user,dbc_passw)
		self.datah = datah
		
	def postRunescape(self,account_number,infoGen):
		email = infoGen.getEmail(account_number)
		passw = infoGen.getPassword(6)
		name = infoGen.getName()
		while self.checkName(name) == False:
			name = infoGen.getName()
		
		day = random.randint(1,28)
		month = random.randint(1,12)
		year = random.randint(1987,2000)
		
		captcha = self.solveCaptcha()
		
		print("Account Info Generated:")
		print("    %s" % (email))
		print("    %s" % (passw))		
		print("    %s" % (name))		
		print("    %s" % (captcha))	
		print("POSTING")		
		
		r = requests.post("https://secure.runescape.com/m=account-creation/create_account",data={ 
			'day':day,
			'displayname':name,
			'email1':email,
			'g-recaptcha-response':captcha["text"],
			'month':month,
			'onlyOneEmail':1,
			'onlyOnePassword':1,
			'password1':passw,
			'submit':'Play+Now',
			'theme':['oldschool','oldschool'],
			'year':year
		})
		
		print("POST reponse: %s" % (r))
		if r.ok:
			print("Checking Created...")
			if self.checkName(name) == False:
				print("Successfully Created! Saving")
				acc = [name,email,passw]
				self.datah.writeAccount(acc)
			else:
				print ("Error creating account: %s"%(email))
				print("Reporting captcha, exiting thread...")
				self.client.report(captcha["captcha"])
				sys.exit()
		else:
			print ("Error creating account: %s"%(email))
			print("Reporting captcha, exiting thread...")
			self.client.report(captcha["captcha"])
			sys.exit()
	
	def checkName(self,name):
		print("Checking name: %s" % (name))
		r = requests.post("https://secure.runescape.com/m=account-creation/check_displayname.ajax",headers={'Referer':'https://secure.runescape.com/m=account-creation/create_account?theme=oldschool'},data={'displayname':name})
		output = str(r.content)
		if "true" in output:
			print("Output from displayname check: True")
			return True
		else:
			print("Output from displayname check: False")
			return False
		
	
	def solveCaptcha(self):
		captcha_in = {
			'googlekey': '6LccFA0TAAAAAHEwUJx_c1TfTBWMTAOIphwTtd1b',
			'pageurl': 'https://secure.runescape.com/m=account-creation/create_account?theme=oldschool'
		}
		captcha_json = json.dumps(captcha_in)
		try:
			solved_captcha = self.client.decode(type=4,token_params=captcha_json)
			if solved_captcha:
				#print ("CAPTCHA %s solved: %s" % (solved_captcha["captcha"], solved_captcha["text"]))
				if solved_captcha["text"] == '':
					self.client.report(solved_captcha["captcha"])
					print ("'' captcha, exitting")
					sys.exit()
					return
				if solved_captcha["text"] == '?':
					self.client.report(solved_captcha["captcha"])
					print ("? captcha, exitting")
					sys.exit()
					return
				if solved_captcha["text"] == None:
					self.client.report(solved_captcha["captcha"])
					print ("None captcha, exitting")
					sys.exit()
					return
				return (solved_captcha)
			else:
				print ("error with captcha, exitting")
				sys.exit()
				return
		except deathbycaptcha.AccessDeniedException:
			print ("error: Access to DBC API denied, check your credentials and/or balance")
			sys.exit()
			return
		
#Generates calculated emails, pseudorandom names, and random passwords
class InfoGenerator:
	def __init__(self,word_array,email_pre,email_suf):
		self.word_array = word_array
		self.email_pre = email_pre
		self.email_suf = email_suf

	#Generates a single email
	#{email_pre}{number}@{email_suf}
	def getEmail(self,number):
		email = self.email_pre+str(number)+"@"+email_suf
		return email
	
	#Generate an arbitary amount of emails
	#{email_pre}{starting_number+i(amount_to_create)}@{email_suf}
	def getEmails(self,starting_number,amount_to_create):
		emails = []
		for n in range(amount_to_create):
			emails.append(self.getEmail(starting_number+n))
		return emails
	
	#Generates a single password of an arbitrary length
	def getPassword(self,length):
		paas = ''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=length))
		return paas
		
	#Generates an arbitary amount passwords of an arbitrary length
	def getPasswords(self,length,amount_to_create):
		paass = []
		for n in range(amount_to_create):
			paass.append(''.join(random.choices(string.ascii_uppercase + string.ascii_lowercase + string.digits, k=length)))
		return paass
		
		
	#Generates a single name
	def getName(self):
		first_word = self.getFirstWord()
		name = self.finishName(first_word)
		return name
	
	#Generate an arbitary amount of names
	def getNames(self,amount_to_create):
		names = []
		for n in range(amount_to_create):
			first_word = self.getFirstWord()
			names.append(self.finishName(first_word))
		return names
		
	#Picks a random word from the word_array and adds numbers before and/or after
	def getFirstWord(self):
		self.sortWords()
		rand = random.randint(0,len(self.lt_array)-1)
		rand_lt = self.lt_array[rand]
		rand_word = rand_lt[random.randint(0,len(rand_lt)-1)]
		num_chance = random.randint(1,4)
		
		#Random Chance to add Numbers before and/or after the first word
		#Can be modified for different "more realistic" name scheme
		if num_chance == 4:
			first_word = str(random.randint(0,99))+rand_word
		elif num_chance == 3:
			first_word = rand_word+str(random.randint(0,99))
		elif num_chance == 2:
			first_word = str(random.randint(0,99))+rand_word+str(random.randint(0,99))
		elif num_chance == 1:
			first_word = rand_word
		
		return first_word
	
	#Gets a second word from the word_array and adds numbers to the rest of the name if applicable
	def finishName(self,first_word):
		able_lt = self.calculateSpacesLeft(first_word)
		sec_word = able_lt[random.randint(0,len(able_lt)-1)]
		proto_name = first_word+sec_word
		name_len = len(proto_name)
		if name_len<12:
			name=proto_name+str(random.randint(1,10**((12-name_len)-1)))
		else:
			name=proto_name
		return name
	
	#Calculates the spaces left in the name given the first word
	#returns a word array of words that can still fit
	def calculateSpacesLeft(self,first_word):
		able_calc = 12-len(first_word)
		if able_calc >= 10:
			able_lt = self.lt10
		elif able_calc == 9:
			able_lt = self.lt9
		elif able_calc == 8:
			able_lt = self.lt8
		elif able_calc == 7:
			able_lt = self.lt7
		elif able_calc == 6:
			able_lt = self.lt6
		elif able_calc == 5:
			able_lt = self.lt5
		elif able_calc == 4:
			able_lt = self.lt4
		elif able_calc == 3:
			able_lt = self.lt3
		elif able_calc == 2:
			able_lt = self.lt2
		elif able_calc == 1:
			able_lt = self.lt1
			
		return able_lt
		
	
	def sortWords(self):
		self.lt10 = []
		self.lt9 = []
		self.lt8 = []
		self.lt7 = []
		self.lt6 = []
		self.lt5 = []
		self.lt4 = []
		self.lt3 = []
		self.lt2 = []
		self.lt1 = []
		for ea in self.word_array:
			if len(ea) > 10:
				print ("Discarded word: %s"%(ea))
			if len(ea) <= 10:
				self.lt10.append(ea)
			if len(ea) <= 9:
				self.lt9.append(ea)
			if len(ea) <= 8:
				self.lt8.append(ea)
			if len(ea) <= 7:
				self.lt7.append(ea)
			if len(ea) <= 6:
				self.lt6.append(ea)
			if len(ea) <= 5:
				self.lt5.append(ea)
			if len(ea) <= 4:
				self.lt4.append(ea)
			if len(ea) <= 3:
				self.lt3.append(ea)
			if len(ea) <= 2:
				self.lt2.append(ea)
			if len(ea) <= 1:
				self.lt1.append(ea)
		self.lt_array = [self.lt10,self.lt9,self.lt8,self.lt7,self.lt6,self.lt5,self.lt4,self.lt3,self.lt2,self.lt1]

class DataHandler:
	
	def __init__(self,dbc=None):
		if dbc == None:
			self.dbc = "accounts.csv"
		else:
			self.dbc = dbc;

	def writeAccount(self,data):
		if self.dbc == "accounts.csv":
			with open(self.dbc,"a") as accFile:
				writer = csv.writer(accFile)
				writer.writerow(data)
		else:
			print("shitfuck not implemented yet")

#Our abstract code
if len(sys.argv) == 8 or len(sys.argv) == 9:
	dbc_user = str(sys.argv[1])
	dbc_passw = str(sys.argv[2])
	email_pre = str(sys.argv[3])
	email_suf = str(sys.argv[4])
	amount_to_create = int(sys.argv[5])
	starting_number = int(sys.argv[6])
	group_count = int(sys.argv[7])
	if len(sys.argv) == 9:
		dbconn = int(sys.argv[8])
	else:
		dbconn = None
	
	print ("Creating %d accounts, assigned to email %s@%s starting at %d" % (amount_to_create, email_pre, email_suf, starting_number))
	print ("Using %d threads at a time" % (group_count))
	#print("Creating one account cuz test")
	
	infoGen = InfoGenerator(word_array,email_pre,email_suf)
	datah = DataHandler(dbconn)
	poster = Poster(dbc_user,dbc_passw,datah)
	
	groups = int(math.ceil(amount_to_create/group_count))
	created = amount_to_create
	
	for ea in range(groups):
		if (created-group_count)<0:
			create = (created-group_count)+group_count
		else:
			create = group_count
		thr = [None]*create
		for i in range(create):
			thr[i] = threading.Thread(target=poster.postRunescape, args=(int(((ea*create)+i)+starting_number),infoGen), kwargs={})
			thr[i].start()
			created-=1
		thr[-1].join()
	
else:
	print ("Missing arguments, exitting")
	print ("Usage:")
	print ("	python asyncCreator.py deathbycaptcha_username deathbycaptcha_password email_prefix email_suffix amount_to_create starting_number thread_count")
	print ("For information about each param see the forum thread:")
	print ("	https://dreambot.org/forums/index.php?/topic/16139-python-account-generator/")
	sys.exit()