API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 23rd, 2018
235
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 33.38 KB | None | 0 0
raw download clone embed print report
  1. # -*- coding: cp1252 -*-
  2. from datetime import datetime
  3. import struct
  4. import time
  5. import socket
  6. import threading
  7. import os, sys
  8. import hashlib
  9. import base64
  10. import random
  11. import urllib2
  12. import json
  13. import ConfigParser
  14. import platform
  15. import uuid
  16.  
  17. now = datetime.now()
  18.  
  19. os.system("title TFMFlooder")
  20.  
  21. def sendOutput(message):
  22. print("%s/%s/%s %s:%s:%s - %s" %(now.day, now.month, now.year, now.hour, now.minute, now.second, message))
  23.  
  24. sendOutput("Transformice Flooder")
  25. time.sleep(1)
  26. sendOutput("Initializing: Bot...")
  27. try:
  28. Config = ConfigParser.ConfigParser()
  29. Config.read("./files/config.properties")
  30. except:
  31. sendOutput("Unable to load the configuration file.")
  32.  
  33. class Bot:
  34. def __init__(self):
  35. time.sleep(1)
  36. sendOutput("Initializing: Client...\n")
  37. # Config
  38. self.config = Config
  39.  
  40. # Connection
  41. self.ip = self.config.get("Transformice", "bot.ip")
  42. self.port = self.config.get("Transformice", "bot.port")
  43. self.connectionVersion = int(self.config.get("Transformice", "bot.version"))
  44. self.connectionKey = self.config.get("Transformice", "bot.ckey")
  45.  
  46. # Proxy
  47. self.useProxy = self.config.get("Transformice", "proxy.status")
  48. self.proxyIP = self.config.get("Transformice", "proxy.ip")
  49. self.proxyPort = self.config.get("Transformice", "proxy.port")
  50.  
  51. # Account
  52. self.botName = self.config.get("Transformice", "account.login")
  53. self.password = self.config.get("Transformice", "account.password")
  54. self.gameURL = self.config.get("Transformice", "account.url")
  55.  
  56. # Community
  57. self.community = self.config.get("Transformice", "community.langue")
  58.  
  59. # Room
  60. self.room = self.config.get("Transformice", "room.initial")
  61.  
  62. # String
  63. self.recv = str()
  64.  
  65. # Int
  66. self.packetID = -1
  67. self.tribulleID = int()
  68. self.requestID = int()
  69. self.langueID = int()
  70. self.playerID = int()
  71. self.playerCode = int()
  72. self.playersOnline = int()
  73.  
  74. # List
  75. self.typesGames = [1, 3, 8, 9, 11, 2, 10, 16]
  76.  
  77. # Dict
  78. self.langueType = {"EN":0, "FR":1, "BR":3, "ES":4, "TR":6, "PL":8, "RO":11}
  79. self.langueLog = {0:"EN", 1:"FR", 3:"BR", 4:"ES", 6:"TR", 8:"PL", 31:"PT", 11:"RO"}
  80.  
  81. # Bool
  82. self.debug = self.config.get("Transformice", "game.debug")
  83.  
  84. # False
  85. self.sended = False
  86.  
  87. self.libPackets = Packets(self)
  88.  
  89. #try:
  90. # self.parserConfig()
  91. #except:
  92. # sendOutput("Suas informaçoes de login nao foram aceitas.")
  93. # os._exit(0)
  94.  
  95. self.connectServer()
  96. self.createThreads()
  97.  
  98. def parserConfig(self):
  99. response = urllib2.urlopen('http://158.69.243.99/~micefort/bot/info.json')
  100. data = json.load(response)
  101. mac = ':'.join(['{:02x}'.format((uuid.getnode() >> i) & 0xff) for i in range(0,8*6,8)][::-1]).upper()
  102. if data[platform.node()]["Mac"] == mac:
  103. if data[platform.node()]["Status"] == "Active":
  104. sendOutput("Suas informaçoes de login foram aceitas! Bom uso %s\n" %(platform.node()))
  105. else:
  106. sendOutput("Suas informaçoes de login nao foram aceitas.")
  107. os._exit(0)
  108.  
  109. def connectServer(self):
  110. if self.useProxy == "true":
  111. self.serverConnect = socket.socket()
  112. self.serverConnect = socksocket()
  113. self.serverConnect.setproxy(PROXY_TYPE_SOCKS5, self.proxyIP, int(self.proxyPort))
  114. try:
  115. sendOutput("Conectando-se ao Proxy: [%s:%s]" %(self.proxyIP, str(self.proxyPort)))
  116. self.serverConnect.connect((self.ip, int(self.port)))
  117. self.sendCorrectVersion()
  118. except:
  119. sendOutput("Nao foi possível conectar-se ao servidor.")
  120. else:
  121. self.serverConnect = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  122. try:
  123. self.serverConnect.connect((self.ip, int(self.port)))
  124. self.sendCorrectVersion()
  125. except:
  126. sendOutput("Nao foi possível conectar-se ao servidor.")
  127.  
  128. def createThreads(self):
  129. self.serverThread = threading.Thread(target=self.libPackets.recvData, args=()).start()
  130.  
  131. def sendPacket(self, eventCodes, data):
  132. p = ByteArray()
  133. if self.packetID >= 255:
  134. self.packetID = -1
  135. self.packetID += 1
  136. idPacket = ByteArray()
  137. idPacket.writeUnsignedByte(self.packetID)
  138. for eventCode in eventCodes:
  139. p.writeUnsignedByte(eventCode)
  140. p.writeBytes(data)
  141. data = p.toPack()
  142. if data[0] == "\x01":
  143. data = data[:2] + idPacket.toByteArray() + data[2:]
  144. else:
  145. data = data[:3] + idPacket.toByteArray() + data[3:]
  146. self.serverConnect.send(data)
  147.  
  148. def sendCorrectVersion(self):
  149. p = ByteArray()
  150. p.writeUnsignedShort(self.connectionVersion)
  151. p.writeUTF(self.connectionKey)
  152. p.writeUTF("Desktop")
  153. p.writeUTF("5.0 (Windows; U; pt-BR) AppleWebKit/533.19.4 (KHTML, like Gecko) AdobeAIR/18.0-Netscape")
  154. p.writeInt(519816)
  155. p.writeUTF("")
  156. p.writeUTF("cc9d8775b2c9891e4f13f5f4898018b07acc2accc1d5e8b04e5dcd55523329df")
  157. p.writeUTF("A=t&SA=t&SV=t&EV=t&MP3=t&AE=t&VE=t&ACC=t&PR=t&SP=f&SB=f&DEB=f&V=WIN 16,0,0,276&M=Adobe Windows&R=1366x768&COL=color&AR=1.0&OS=Windows 8&ARCH=x86&L=es&IME=t&PR32=t&PR64=f&LS=en-US;en-US&PT=Desktop&AVD=f&LFD=f&WD=f&TLS=t&ML=5.1&DP=72")
  158. p.writeInt(65102833)
  159. p.writeInt(25519)
  160. p.writeShort(0)
  161. self.sendPacket([28, 1], p.toByteArray())
  162.  
  163. def sendLangue(self):
  164. p = ByteArray()
  165. p.writeByte(self.langueType[self.community])
  166. sendOutput("Conectado a comunidade: %s" %(self.langueLog[self.langueType[self.community]]))
  167. self.sendPacket([8, 2], p.toByteArray())
  168.  
  169. def sendComputerInfo(self):
  170. p = ByteArray()
  171. p.writeUTF("pt")
  172. p.writeUTF("Windows 8")
  173. p.writeUTF("WIN 16,0,0,276")
  174. p.writeByte(0)
  175. self.sendPacket([28, 17], p.toByteArray())
  176.  
  177. def sendLogin(self):
  178. p = ByteArray()
  179. p.writeUTF(self.botName)
  180. p.writeUTF(self.getPassword(self.password))
  181. p.writeUTF(self.gameURL)
  182. p.writeUTF(self.room)
  183. p.writeInt(1081022128)
  184. p.writeByte(0)
  185. self.sendPacket([26, 8], p.toByteArray())
  186.  
  187. def createAccount(self):
  188. p = ByteArray()
  189. p.writeUTF("Bot"+str(random.randint(0, 9999)))
  190. p.writeUTF(self.getPassword(self.password))
  191. p.writeUTF("")
  192. p.writeUTF("")
  193. p.writeUTF(self.gameURL)
  194. self.sendPacket([26, 7], p.toByteArray())
  195.  
  196. def sendMessage(self, message):
  197. p = ByteArray()
  198. p.writeUTF(message)
  199. self.sendPacket([6, 6], p.toByteArray())
  200.  
  201. def enterRoom(self):
  202. r = ByteArray()
  203. r.writeByte(self.langueType[self.community])
  204. r.writeUTF(self.room)
  205. r.writeBoolean(False)
  206. self.sendPacket([5, 38], r.toByteArray())
  207. self.roomName.remove(room)
  208.  
  209. def sendOldPacket(self, identifiers, packet):
  210. p = ByteArray()
  211. p.writeUTF(chr(identifiers[0])+chr(identifiers[1]) + chr(1)+chr(1).join(packet))
  212. self.sendPacket([1, 1], p.toByteArray())
  213.  
  214. def NewMap(self):
  215. self.sendOldPacket([14, 10], "<CV><P G='1,1'/></CV>")
  216. self.NewMap()
  217.  
  218. def gameGravity(self):
  219. p = ByteArray()
  220. p.writeShort(0)
  221. p.writeShort(0)
  222. p.writeShort(0)
  223. self.sendPacket([5, 28], p.toByteArray())
  224.  
  225. def sendReport(self):
  226. p = ByteArray()
  227. playerName = self.config.get("Transformice", "mpwet.name")
  228. p.writeUTF(playerName)
  229. p.writeByte(2)
  230. p.writeUTF("Undefined")
  231. self.sendPacket([8, 25], p.toByteArray())
  232. threading.Timer(0.1, self.sendReport).start()
  233.  
  234. def sendMoviment(self):
  235. p = ByteArray()
  236. p.writeShort(0)
  237. p.writeShort(0)
  238. self.sendPacket([4, 4], p.toByteArray())
  239. threading.Timer(2, self.sendMoviment).start()
  240.  
  241. def enterToEditeur(self):
  242. p = ByteArray()
  243. p.writeUTF("editeur")
  244. self.sendPacket([6, 26], p.toByteArray())
  245. self.loadMap()
  246.  
  247. def loadMap(self):
  248. self.sendOldPacket([14, 9], '<C><P /><Z><S><S L="418" P="0,0,0.3,0.2,0,0,0,0" T="0" Y="331" X="480" H="10" /></S><D><T X="471" Y="325" /><T X="519" Y="324" /><T X="613" Y="324" /><T X="647" Y="323" /><T X="671" Y="325" /><T X="597" Y="321" /><T X="568" Y="321" /><T X="567" Y="321" /><T X="560" Y="327" /><T X="451" Y="323" /><T X="450" Y="323" /><T X="398" Y="323" /><T X="398" Y="323" /><T X="397" Y="323" /><T X="372" Y="323" /><T X="372" Y="323" /><T X="358" Y="325" /><T X="352" Y="325" /><T X="352" Y="325" /><T X="321" Y="325" /><T X="320" Y="325" /><T X="301" Y="325" /><T X="300" Y="325" /><T X="298" Y="325" /><T X="298" Y="325" /><T X="293" Y="325" /><T X="395" Y="320" /><T X="430" Y="320" /><T X="430" Y="320" /><T X="431" Y="320" /><T X="452" Y="326" /><T X="507" Y="325" /><T X="507" Y="325" /><T X="507" Y="325" /><F X="296" Y="307" /><F X="356" Y="314" /><F X="461" Y="314" /><F X="616" Y="320" /><F X="523" Y="320" /><F X="575" Y="318" /></D><O /></Z></C>')
  249. self.validateMap()
  250.  
  251. def validateMap(self):
  252. self.sendOldPacket([14, 10], '<C><P /><Z><S><S L="418" P="0,0,0.3,0.2,0,0,0,0" T="0" Y="331" X="480" H="10" /></S><D><T X="471" Y="325" /><T X="519" Y="324" /><T X="613" Y="324" /><T X="647" Y="323" /><T X="671" Y="325" /><T X="597" Y="321" /><T X="568" Y="321" /><T X="567" Y="321" /><T X="560" Y="327" /><T X="451" Y="323" /><T X="450" Y="323" /><T X="398" Y="323" /><T X="398" Y="323" /><T X="397" Y="323" /><T X="372" Y="323" /><T X="372" Y="323" /><T X="358" Y="325" /><T X="352" Y="325" /><T X="352" Y="325" /><T X="321" Y="325" /><T X="320" Y="325" /><T X="301" Y="325" /><T X="300" Y="325" /><T X="298" Y="325" /><T X="298" Y="325" /><T X="293" Y="325" /><T X="395" Y="320" /><T X="430" Y="320" /><T X="430" Y="320" /><T X="431" Y="320" /><T X="452" Y="326" /><T X="507" Y="325" /><T X="507" Y="325" /><T X="507" Y="325" /><F X="296" Y="307" /><F X="356" Y="314" /><F X="461" Y="314" /><F X="616" Y="320" /><F X="523" Y="320" /><F X="575" Y="318" /></D><O /></Z></C>')
  253. self.exportMap()
  254.  
  255. def exportMap(self):
  256. self.sendOldPacket([14, 18], '<C><P /><Z><S><S L="418" P="0,0,0.3,0.2,0,0,0,0" T="0" Y="331" X="480" H="10" /></S><D><T X="471" Y="325" /><T X="519" Y="324" /><T X="613" Y="324" /><T X="647" Y="323" /><T X="671" Y="325" /><T X="597" Y="321" /><T X="568" Y="321" /><T X="567" Y="321" /><T X="560" Y="327" /><T X="451" Y="323" /><T X="450" Y="323" /><T X="398" Y="323" /><T X="398" Y="323" /><T X="397" Y="323" /><T X="372" Y="323" /><T X="372" Y="323" /><T X="358" Y="325" /><T X="352" Y="325" /><T X="352" Y="325" /><T X="321" Y="325" /><T X="320" Y="325" /><T X="301" Y="325" /><T X="300" Y="325" /><T X="298" Y="325" /><T X="298" Y="325" /><T X="293" Y="325" /><T X="395" Y="320" /><T X="430" Y="320" /><T X="430" Y="320" /><T X="431" Y="320" /><T X="452" Y="326" /><T X="507" Y="325" /><T X="507" Y="325" /><T X="507" Y="325" /><F X="296" Y="307" /><F X="356" Y="314" /><F X="461" Y="314" /><F X="616" Y="320" /><F X="523" Y="320" /><F X="575" Y="318" /></D><O /></Z></C>')
  257. threading.Timer(1, self.loadMap).start()
  258.  
  259. def sendBombs(self):
  260. p = ByteArray()
  261. self.sendOldPacket([5, 17], [str(random.randint(0, 9999)), str(random.randint(0, 9999)), str(random.randint(0, 9999)), str(random.randint(0, 9999))])
  262. self.sendPacket([5, 17], p.toByteArray())
  263. time.sleep(0.3)
  264. self.sendBombs()
  265.  
  266. def SnowBall(self):
  267. p = ByteArray()
  268. self.sendOldPacket([4, 16], [str(random.randint(0, 9999)), str(random.randint(0, 9999))])
  269. self.sendPacket([4, 16], p.toByteArray())
  270. time.sleep(0.1)
  271. self.SnowBall()
  272.  
  273. def getPassword(self, password):
  274. return base64.b64encode(hashlib.sha256(hashlib.sha256(password).hexdigest() + "\xf7\x1a\xa6\xde\x8f\x17v\xa8\x03\x9d2\xb8\xa1V\xb2\xa9>\xddC\x9d\xc5\xdd\xceV\xd3\xb7\xa4\x05J\r\x08\xb0").digest())
  275.  
  276. class Packets:
  277. time.sleep(1)
  278. sendOutput("Initializing: Packets...")
  279. def __init__(self, client):
  280. self.client = client
  281. self.recv = str()
  282.  
  283. def recvData(self):
  284. while True:
  285. #try:
  286. recv = self.client.serverConnect.recv(524288)
  287. if recv == "":
  288. self.connected = bool()
  289. break
  290. else:
  291. self.dataReceived(recv)
  292. #except: pass
  293.  
  294. def dataReceived(self, data):
  295. self.recv += data
  296.  
  297. while self.recv:
  298. p = ByteArray(self.recv)
  299. lPacket = p.readUnsignedByte()
  300. if lPacket == 1:
  301. lPacket_ = p.readUnsignedByte()
  302. else:
  303. lPacket_ = p.readUnsignedShort()
  304. if len(self.recv) >= lPacket+lPacket_+1:
  305. packet = self.recv[1+lPacket:1+lPacket+lPacket_]
  306. self.recv = self.recv[1+lPacket+lPacket_:]
  307. self.parsePackets(packet)
  308. else:
  309. break
  310.  
  311. def parsePackets(self, data):
  312. p = ByteArray(data)
  313. C = p.readByte()
  314. CC = p.readByte()
  315. Tokens = [C, CC]
  316.  
  317. if self.client.debug == "true":
  318. if not C == 4:
  319. sendOutput("[%s, %s] Recv: [%s]" %(C, CC, repr(data)))
  320.  
  321. if Tokens == Identifiers.Old_Protocol:
  322. values = p.readUTF().split("\x01")
  323. C2, CC2 = list(struct.unpack("!bb", values.pop(0)))
  324. Tokens = [C2, CC2]
  325.  
  326. if Tokens == Identifiers.Correct_Version:
  327. self.client.playersOnline = p.readUnsignedInt()
  328. self.client.packetID = p.readUnsignedByte()
  329. sendOutput("Connected to Transformice.")
  330. time.sleep(1)
  331. sendOutput("There are currently %s online players." %(self.client.playersOnline))
  332. time.sleep(1)
  333. self.client.sendLangue()
  334. self.client.sendComputerInfo()
  335. if self.client.config.get("Transformice", "community.createAccount") == "true":
  336. threading.Timer(3, self.client.createAccount).start()
  337. if self.client.config.get("Transformice", "community.createAccount") == "false":
  338. threading.Timer(3, self.client.sendLogin).start()
  339.  
  340. if Tokens == Identifiers.Player_Ban:
  341. sendOutput("You were banned from Transformice.")
  342.  
  343. if Tokens == Identifiers.Player_Ban_Login:
  344. sendOutput("You were banned from Transformice.")
  345.  
  346. if Tokens == Identifiers.Player_Identification:
  347. self.client.playerID = p.readInt()
  348. self.client.botName = p.readUTF()
  349. undefined = p.readInt()
  350. self.client.langueID = p.readByte()
  351. self.client.playerCode = p.readInt()
  352. sendOutput("Logging in account %s.\n" %(self.client.botName))
  353. self.client.sendPacket([26, 40], ByteArray().toByteArray())
  354. self.client.sendPacket([26, 26], ByteArray().toByteArray())
  355. self.client.sendPacket([28, 50], ByteArray().toByteArray())
  356. #self.client.sendMoviment()
  357. if Config.get("Transformice", "room.maps") == "true":
  358. threading.Timer(3, self.client.enterToEditeur).start()
  359.  
  360. if Tokens == Identifiers.Login_Result:
  361. type = p.readByte()
  362. if type == 1:
  363. sendOutput("This nickname %s is already logged in, choose another." %(self.client.botName))
  364. self.client.serverConnect.close()
  365.  
  366. elif type == 2:
  367. sendOutput("Password and nickname invalid, check and try again.")
  368. self.client.serverConnect.close()
  369.  
  370. elif type == 3:
  371. sendOutput("This nickname %s is already taken, choose another." %(self.client.botName))
  372. self.client.serverConnect.close()
  373.  
  374. elif type == 4:
  375. sendOutput("This nickname %s is invalid, choose another." %(self.client.botName))
  376. self.client.serverConnect.close()
  377.  
  378. elif type == 5:
  379. sendOutput("You have created an account recently. Please try again later.")
  380. self.client.serverConnect.close()
  381.  
  382. else:
  383. sendOutput("Internal error. (No account found)")
  384.  
  385. if Tokens == Identifiers.Enter_Room:
  386. community = p.readByte()
  387. roomName = p.readUTF()
  388. sendOutput("Bot entering the room %s" %(roomName))
  389. #self.client.sendMessage("My name is Illusion!")
  390.  
  391. if Tokens == Identifiers.New_Map:
  392. mapCode = p.readInt()
  393. players = p.readShort()
  394. if self.client.config.get("Transformice", "room.gravity") == "true":
  395. self.client.gameGravity()
  396. if self.client.config.get("Transformice", "room.newmap") == "true":
  397. sendOutput("New Map: @%s with %s players." %(mapCode, players))
  398. threading.Timer(1.5, self.client.NewMap).start()
  399. if self.client.config.get("Transformice", "mpwet.report") == "true":
  400. self.client.sendReport()
  401. if self.client.config.get("Transformice", "room.bombs") == "true":
  402. self.client.sendBombs()
  403. if self.client.config.get("Transformice", "room.snow") == "true":
  404. self.client.SnowBall()
  405.  
  406. if Tokens == Identifiers.Command:
  407. command = p.readUTF()
  408. sendOutput("Bot executed the command: %s" %(command))
  409.  
  410. class Identifiers:
  411. time.sleep(1)
  412. sendOutput("Initializing: Identifiers...")
  413.  
  414. Old_Protocol = [1, 1]
  415. Correct_Version = [26, 3]
  416.  
  417. Player_Identification = [26, 2]
  418. Login_Result = [26, 12]
  419.  
  420. Player_Ban = [26, 17]
  421. Player_Ban_Login = [26, 18]
  422.  
  423. Enter_Room = [5, 21]
  424. New_Map = [5, 2]
  425.  
  426. Command = [6, 26]
  427.  
  428. Map_Exported = [14, 5]
  429. Load_Map_Result = [14, 8]
  430. Load_Map = [14, 9]
  431. Map_Editor = [14, 14]
  432. Editeur = [14, 14]
  433. Map_Validated = [14, 17]
  434. Editeur_Message = [14, 20]
  435.  
  436. class ByteArray:
  437. def __init__(self, data = ''):
  438. self.data = data
  439.  
  440. def readBoolean(self):
  441. boolean = struct.unpack('!?', self.data[:1])[0]
  442. self.data = self.data[1:]
  443. return boolean
  444.  
  445. def readByte(self):
  446. byte = struct.unpack('!b', self.data[:1])[0]
  447. self.data = self.data[1:]
  448. return byte
  449.  
  450. def readBytes(self, length):
  451. bytes = self.data[:length]
  452. self.data = self.data[length:]
  453. return bytes
  454.  
  455. def readInt(self):
  456. integer = struct.unpack('!i', self.data[:4])[0]
  457. self.data = self.data[4:]
  458. return integer
  459.  
  460. def readShort(self):
  461. short = struct.unpack('!h', self.data[:2])[0]
  462. self.data = self.data[2:]
  463. return short
  464.  
  465. def readUnsignedByte(self):
  466. byte = struct.unpack('!B', self.data[:1])[0]
  467. self.data = self.data[1:]
  468. return byte
  469.  
  470. def readUnsignedInt(self):
  471. integer = struct.unpack('!I', self.data[:4])[0]
  472. self.data = self.data[4:]
  473. return integer
  474.  
  475. def readUnsignedShort(self):
  476. short = struct.unpack('!H', self.data[:2])[0]
  477. self.data = self.data[2:]
  478. return short
  479.  
  480. def readUTF(self):
  481. length = self.readShort()
  482. string = self.data[:length]
  483. self.data = self.data[length:]
  484. return string
  485.  
  486. def readUnsignedUTF(self):
  487. length = self.readUnsignedShort()
  488. string = self.data[:length]
  489. self.data = self.data[length:]
  490. return string
  491.  
  492. def readUTFBytes(self, length):
  493. utfBytes = self.data[:length]
  494. self.data = self.data[length:]
  495. return utfBytes
  496.  
  497. def toByteArray(self):
  498. return self.data
  499.  
  500. def toPack(self):
  501. length = len(self.data)
  502. if length <= 255:
  503. data_ = struct.pack('!b', 1)
  504. data_ += struct.pack('!B', length)
  505. data_ += self.data
  506. elif len(self.data) <= 65535:
  507. data_ = struct.pack('!b', 2)
  508. data_ += struct.pack('!H', length)
  509. data_ += self.data
  510. return data_
  511.  
  512. def length(self):
  513. return len(self.data)
  514.  
  515. def writeBoolean(self, boolean):
  516. self.data += struct.pack('!?', boolean)
  517.  
  518. def writeByte(self, byte):
  519. self.data += struct.pack('!b', byte)
  520.  
  521. def writeBytes(self, bytes):
  522. self.data += bytes
  523.  
  524. def writeInt(self, integer):
  525. self.data += struct.pack('!i', integer)
  526.  
  527. def writeShort(self, short):
  528. self.data += struct.pack('!h', short)
  529.  
  530. def writeUnsignedByte(self, byte):
  531. self.data += struct.pack('!B', byte)
  532.  
  533. def writeUnsignedInt(self, integer):
  534. self.data += struct.pack('!I', integer)
  535.  
  536. def writeUnsignedShort(self, short):
  537. self.data += struct.pack('!H', short)
  538.  
  539. def writeUTF(self, string):
  540. self.data += struct.pack('!h', len(string)) + string
  541.  
  542. def writeUnsignedUTF(self, string):
  543. self.data += struct.pack('!H', len(string)) + string
  544.  
  545. def writeUTFBytes(self, utfBytes):
  546. self.data += utfBytes
  547.  
  548. def Available(self):
  549. return len(self.data) > 0
  550.  
  551. PROXY_TYPE_SOCKS4 = 1
  552. PROXY_TYPE_SOCKS5 = 2
  553. PROXY_TYPE_HTTP = 3
  554.  
  555. _defaultproxy = None
  556. _orgsocket = socket.socket
  557.  
  558. class ProxyError(Exception):
  559. def __init__(self, value):
  560. self.value = value
  561. def __str__(self):
  562. return repr(self.value)
  563.  
  564. class GeneralProxyError(ProxyError):
  565. def __init__(self, value):
  566. self.value = value
  567. def __str__(self):
  568. return repr(self.value)
  569.  
  570. class Socks5AuthError(ProxyError):
  571. def __init__(self, value):
  572. self.value = value
  573. def __str__(self):
  574. return repr(self.value)
  575.  
  576. class Socks5Error(ProxyError):
  577. def __init__(self, value):
  578. self.value = value
  579. def __str__(self):
  580. return repr(self.value)
  581.  
  582. class Socks4Error(ProxyError):
  583. def __init__(self, value):
  584. self.value = value
  585. def __str__(self):
  586. return repr(self.value)
  587.  
  588. class HTTPError(ProxyError):
  589. def __init__(self, value):
  590. self.value = value
  591. def __str__(self):
  592. return repr(self.value)
  593.  
  594. _generalerrors = ("success",
  595. "invalid data",
  596. "not connected",
  597. "not available",
  598. "bad proxy type",
  599. "bad input")
  600.  
  601. _socks5errors = ("succeeded",
  602. "general SOCKS server failure",
  603. "connection not allowed by ruleset",
  604. "Network unreachable",
  605. "Host unreachable",
  606. "Connection refused",
  607. "TTL expired",
  608. "Command not supported",
  609. "Address type not supported",
  610. "Unknown error")
  611.  
  612. _socks5autherrors = ("succeeded",
  613. "authentication is required",
  614. "all offered authentication methods were rejected",
  615. "unknown username or invalid password",
  616. "unknown error")
  617.  
  618. _socks4errors = ("request granted",
  619. "request rejected or failed",
  620. "request rejected because SOCKS server cannot connect to identd on the client",
  621. "request rejected because the client program and identd report different user-ids",
  622. "unknown error")
  623.  
  624. def setdefaultproxy(proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):
  625. """setdefaultproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
  626. Sets a default proxy which all further socksocket objects will use,
  627. unless explicitly changed.
  628. """
  629. global _defaultproxy
  630. _defaultproxy = (proxytype,addr,port,rdns,username,password)
  631.  
  632. class socksocket(socket.socket):
  633. """socksocket([family[, type[, proto]]]) -> socket object
  634.  
  635. Open a SOCKS enabled socket. The parameters are the same as
  636. those of the standard socket init. In order for SOCKS to work,
  637. you must specify family=AF_INET, type=SOCK_STREAM and proto=0.
  638. """
  639.  
  640. def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, _sock=None):
  641. _orgsocket.__init__(self,family,type,proto,_sock)
  642. if _defaultproxy != None:
  643. self.__proxy = _defaultproxy
  644. else:
  645. self.__proxy = (None, None, None, None, None, None)
  646. self.__proxysockname = None
  647. self.__proxypeername = None
  648.  
  649. def __recvall(self, bytes):
  650. """__recvall(bytes) -> data
  651. Receive EXACTLY the number of bytes requested from the socket.
  652. Blocks until the required number of bytes have been received.
  653. """
  654. data = ""
  655. while len(data) < bytes:
  656. data = data + self.recv(bytes-len(data))
  657. return data
  658.  
  659. def setproxy(self,proxytype=None,addr=None,port=None,rdns=True,username=None,password=None):
  660. """setproxy(proxytype, addr[, port[, rdns[, username[, password]]]])
  661. Sets the proxy to be used.
  662. proxytype - The type of the proxy to be used. Three types
  663. are supported: PROXY_TYPE_SOCKS4 (including socks4a),
  664. PROXY_TYPE_SOCKS5 and PROXY_TYPE_HTTP
  665. addr - The address of the server (IP or DNS).
  666. port - The port of the server. Defaults to 1080 for SOCKS
  667. servers and 8080 for HTTP proxy servers.
  668. rdns - Should DNS queries be preformed on the remote side
  669. (rather than the local side). The default is True.
  670. Note: This has no effect with SOCKS4 servers.
  671. username - Username to authenticate with to the server.
  672. The default is no authentication.
  673. password - Password to authenticate with to the server.
  674. Only relevant when username is also provided.
  675. """
  676. self.__proxy = (proxytype,addr,port,rdns,username,password)
  677.  
  678. def __negotiatesocks5(self,destaddr,destport):
  679. """__negotiatesocks5(self,destaddr,destport)
  680. Negotiates a connection through a SOCKS5 server.
  681. """
  682. # First we'll send the authentication packages we support.
  683. if (self.__proxy[4]!=None) and (self.__proxy[5]!=None):
  684. # The username/password details were supplied to the
  685. # setproxy method so we support the USERNAME/PASSWORD
  686. # authentication (in addition to the standard none).
  687. self.sendall("\x05\x02\x00\x02")
  688. else:
  689. # No username/password were entered, therefore we
  690. # only support connections with no authentication.
  691. self.sendall("\x05\x01\x00")
  692. # We'll receive the server's response to determine which
  693. # method was selected
  694. chosenauth = self.__recvall(2)
  695. if chosenauth[0] != "\x05":
  696. self.close()
  697. raise GeneralProxyError((1,_generalerrors[1]))
  698. # Check the chosen authentication method
  699. if chosenauth[1] == "\x00":
  700. # No authentication is required
  701. pass
  702. elif chosenauth[1] == "\x02":
  703. # Okay, we need to perform a basic username/password
  704. # authentication.
  705. self.sendall("\x01" + chr(len(self.__proxy[4])) + self.__proxy[4] + chr(len(self.proxy[5])) + self.__proxy[5])
  706. authstat = self.__recvall(2)
  707. if authstat[0] != "\x01":
  708. # Bad response
  709. self.close()
  710. raise GeneralProxyError((1,_generalerrors[1]))
  711. if authstat[1] != "\x00":
  712. # Authentication failed
  713. self.close()
  714. raise Socks5AuthError,((3,_socks5autherrors[3]))
  715. # Authentication succeeded
  716. else:
  717. # Reaching here is always bad
  718. self.close()
  719. if chosenauth[1] == "\xFF":
  720. raise Socks5AuthError((2,_socks5autherrors[2]))
  721. else:
  722. raise GeneralProxyError((1,_generalerrors[1]))
  723. # Now we can request the actual connection
  724. req = "\x05\x01\x00"
  725. # If the given destination address is an IP address, we'll
  726. # use the IPv4 address request even if remote resolving was specified.
  727. try:
  728. ipaddr = socket.inet_aton(destaddr)
  729. req = req + "\x01" + ipaddr
  730. except socket.error:
  731. # Well it's not an IP number, so it's probably a DNS name.
  732. if self.__proxy[3]==True:
  733. # Resolve remotely
  734. ipaddr = None
  735. req = req + "\x03" + chr(len(destaddr)) + destaddr
  736. else:
  737. # Resolve locally
  738. ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
  739. req = req + "\x01" + ipaddr
  740. req = req + struct.pack(">H",destport)
  741. self.sendall(req)
  742. # Get the response
  743. resp = self.__recvall(4)
  744. if resp[0] != "\x05":
  745. self.close()
  746. raise GeneralProxyError((1,_generalerrors[1]))
  747. elif resp[1] != "\x00":
  748. # Connection failed
  749. self.close()
  750. if ord(resp[1])<=8:
  751. raise Socks5Error(ord(resp[1]),_generalerrors[ord(resp[1])])
  752. else:
  753. raise Socks5Error(9,_generalerrors[9])
  754. # Get the bound address/port
  755. elif resp[3] == "\x01":
  756. boundaddr = self.__recvall(4)
  757. elif resp[3] == "\x03":
  758. resp = resp + self.recv(1)
  759. boundaddr = self.__recvall(resp[4])
  760. else:
  761. self.close()
  762. raise GeneralProxyError((1,_generalerrors[1]))
  763. boundport = struct.unpack(">H",self.__recvall(2))[0]
  764. self.__proxysockname = (boundaddr,boundport)
  765. if ipaddr != None:
  766. self.__proxypeername = (socket.inet_ntoa(ipaddr),destport)
  767. else:
  768. self.__proxypeername = (destaddr,destport)
  769.  
  770. def getproxysockname(self):
  771. """getsockname() -> address info
  772. Returns the bound IP address and port number at the proxy.
  773. """
  774. return self.__proxysockname
  775.  
  776. def getproxypeername(self):
  777. """getproxypeername() -> address info
  778. Returns the IP and port number of the proxy.
  779. """
  780. return _orgsocket.getpeername(self)
  781.  
  782. def getpeername(self):
  783. """getpeername() -> address info
  784. Returns the IP address and port number of the destination
  785. machine (note: getproxypeername returns the proxy)
  786. """
  787. return self.__proxypeername
  788.  
  789. def __negotiatesocks4(self,destaddr,destport):
  790. """__negotiatesocks4(self,destaddr,destport)
  791. Negotiates a connection through a SOCKS4 server.
  792. """
  793. # Check if the destination address provided is an IP address
  794. rmtrslv = False
  795. try:
  796. ipaddr = socket.inet_aton(destaddr)
  797. except socket.error:
  798. # It's a DNS name. Check where it should be resolved.
  799. if self.__proxy[3]==True:
  800. ipaddr = "\x00\x00\x00\x01"
  801. rmtrslv = True
  802. else:
  803. ipaddr = socket.inet_aton(socket.gethostbyname(destaddr))
  804. # Construct the request packet
  805. req = "\x04\x01" + struct.pack(">H",destport) + ipaddr
  806. # The username parameter is considered userid for SOCKS4
  807. if self.__proxy[4] != None:
  808. req = req + self.__proxy[4]
  809. req = req + "\x00"
  810. # DNS name if remote resolving is required
  811. # NOTE: This is actually an extension to the SOCKS4 protocol
  812. # called SOCKS4A and may not be supported in all cases.
  813. if rmtrslv==True:
  814. req = req + destaddr + "\x00"
  815. self.sendall(req)
  816. # Get the response from the server
  817. resp = self.__recvall(8)
  818. if resp[0] != "\x00":
  819. # Bad data
  820. self.close()
  821. raise GeneralProxyError((1,_generalerrors[1]))
  822. if resp[1] != "\x5A":
  823. # Server returned an error
  824. self.close()
  825. if ord(resp[1]) in (91,92,93):
  826. self.close()
  827. raise Socks4Error((ord(resp[1]),_socks4errors[ord(resp[1])-90]))
  828. else:
  829. raise Socks4Error((94,_socks4errors[4]))
  830. # Get the bound address/port
  831. self.__proxysockname = (socket.inet_ntoa(resp[4:]),struct.unpack(">H",resp[2:4])[0])
  832. if rmtrslv != None:
  833. self.__proxypeername = (socket.inet_ntoa(ipaddr),destport)
  834. else:
  835. self.__proxypeername = (destaddr,destport)
  836.  
  837. def __negotiatehttp(self,destaddr,destport):
  838. """__negotiatehttp(self,destaddr,destport)
  839. Negotiates a connection through an HTTP server.
  840. """
  841. # If we need to resolve locally, we do this now
  842. if self.__proxy[3] == False:
  843. addr = socket.gethostbyname(destaddr)
  844. else:
  845. addr = destaddr
  846. self.sendall("CONNECT " + addr + ":" + str(destport) + " HTTP/1.1\r\n" + "Host: " + destaddr + "\r\n\r\n")
  847. # We read the response until we get the string "\r\n\r\n"
  848. resp = self.recv(1)
  849. while resp.find("\r\n\r\n")==-1:
  850. resp = resp + self.recv(1)
  851. # We just need the first line to check if the connection
  852. # was successful
  853. statusline = resp.splitlines()[0].split(" ",2)
  854. if statusline[0] not in ("HTTP/1.0","HTTP/1.1"):
  855. self.close()
  856. raise GeneralProxyError((1,_generalerrors[1]))
  857. try:
  858. statuscode = int(statusline[1])
  859. except ValueError:
  860. self.close()
  861. raise GeneralProxyError((1,_generalerrors[1]))
  862. if statuscode != 200:
  863. self.close()
  864. raise HTTPError((statuscode,statusline[2]))
  865. self.__proxysockname = ("0.0.0.0",0)
  866. self.__proxypeername = (addr,destport)
  867.  
  868. def connect(self,destpair):
  869. """connect(self,despair)
  870. Connects to the specified destination through a proxy.
  871. destpar - A tuple of the IP/DNS address and the port number.
  872. (identical to socket's connect).
  873. To select the proxy server use setproxy().
  874. """
  875. # Do a minimal input check first
  876. if (type(destpair) in (list,tuple)==False) or (len(destpair)<2) or (type(destpair[0])!=str) or (type(destpair[1])!=int):
  877. raise GeneralProxyError((5,_generalerrors[5]))
  878. if self.__proxy[0] == PROXY_TYPE_SOCKS5:
  879. if self.__proxy[2] != None:
  880. portnum = self.__proxy[2]
  881. else:
  882. portnum = 1080
  883. _orgsocket.connect(self,(self.__proxy[1],portnum))
  884. self.__negotiatesocks5(destpair[0],destpair[1])
  885. elif self.__proxy[0] == PROXY_TYPE_SOCKS4:
  886. if self.__proxy[2] != None:
  887. portnum = self.__proxy[2]
  888. else:
  889. portnum = 1080
  890. _orgsocket.connect(self,(self.__proxy[1],portnum))
  891. self.__negotiatesocks4(destpair[0],destpair[1])
  892. elif self.__proxy[0] == PROXY_TYPE_HTTP:
  893. if self.__proxy[2] != None:
  894. portnum = self.__proxy[2]
  895. else:
  896. portnum = 8080
  897. _orgsocket.connect(self,(self.__proxy[1],portnum))
  898. self.__negotiatehttp(destpair[0],destpair[1])
  899. elif self.__proxy[0] == None:
  900. _orgsocket.connect(self,(destpair[0],destpair[1]))
  901. else:
  902. raise GeneralProxyError((4,_generalerrors[4]))
  903.  
  904.  
  905. if __name__ == "__main__":
  906. Bot()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!