def verify_code(self):
timestemp = time.time()
imgurl = 'http://api.chaxun.la/api/seccode/?0.{0}'.format(timestemp)
if self.download(imgurl):
captcha = Captcha()
code_result = captcha.verification(filename='captcha.gif')
self.verify = code_result.get('Result')
def like(self, photo_id):
captcha = False
captcha_result = ''
captcha_sid = ''
while True:
owner_id, item_id = photo_id.split('_')
if captcha == False:
url = self.getUrl.likes.add(type='photo', owner_id=owner_id, item_id=item_id)
else:
url = self.getUrl.likes.add(type='photo', owner_id=owner_id, item_id=item_id, captcha_sid=captcha_sid, captcha_key=captcha_result)
self.requester(url, self.session)
response = self.requester.request()
for r in response:
j = json.loads(r[0].text)
try:
if 'likes' in j['response']:
with open('files/completed', 'a') as file:
file.write(str(owner_id) + '\n')
print('+', owner_id)
return
except Exception as e:
print(e)
print(r[0].text)
if 'error' in j:
if j['error']['error_code'] == 14:
print("Решаем капчу")
captcha = Captcha()
captcha_result = captcha.solve(self.session, j['error']['captcha_img'])
captcha_sid = j['error']['captcha_sid']
if captcha_result == 'error':
self.interval = 2000
return
else:
captcha = True
print(self.name, 'Captcha', captcha_result)
if j['error']['error_code'] == 15:
with open('files/completed', 'a') as file:
file.write(str(owner_id) + '\n')
print('+', owner_id)
return
if j['error']['error_code'] == 17:
self.interval = 99999
return
def verify_code(self):
timestemp = time.time()
imgurl = 'http://api.chaxun.la/api/seccode/?0.{0}'.format(timestemp)
if self.download(imgurl):
captcha = Captcha()
code_result = captcha.verification(filename='captcha.gif')
self.verify = code_result.get('Result')
class Solver(object):
def __init__(self, network):
self.ann = libfann.neural_net()
self.ann.create_from_file("./networks/{}".format(network))
self.cap_segmenter = Captcha()
self.letters = "abcdefghklmnprstuvwyzABDEFGHIJKLMNRTUXY23456789"
def solve_cap(self, captcha):
self.cap_segmenter.update_cap(captcha)
self.cap_segmenter.segment()
segs = self.cap_segmenter.get_segments()
answer = self.use_ann(segs)
return answer
def to_input(self, seg):
input = []
for x in range(seg.size[0]):
for y in range(seg.size[1]):
p = (x, y)
col = seg.getpixel(p)
norm = (((col / 255.00) * 2.00) - 1.00) * -1.00
input.append(norm)
return input
def use_ann(self, segs):
answer = ''
for seg in segs:
input = self.to_input(seg)
output = self.ann.run(input)
max = [0, -1]
for x in range(len(output)):
if output[x] > max[0]:
max = (output[x], x)
answer += self.letters[max[1]]
return answer
def login(url, parent=None, username=None, password=None):
if (not password) or (not username):
return None
qDebug("in login")
while True:
session = _create_session()
# qDebug("session")
req = _get_login_page(session, url)
# qDebug("page")
captcha_id = re_search(r'img.src = \'captcha\?(.*)\'', req)
# qDebug("captcha")
if not captcha_id:
qDebug('Captcha not found! Retrying...')
sleep(3)
continue
captcha_id += get_timestamp()
captcha_url = 'https://jaccount.sjtu.edu.cn/jaccount/captcha?' +\
captcha_id
code = _bypass_captcha(parent, session, captcha_url)
check = Captcha(parent)
if not check.exec_():
session.close()
return None
code = check.captchaInput.text()
qDebug(code)
sid = re_search(r'sid" value="(.*?)"', req)
returl = re_search(r'returl" value="(.*?)"', req)
se = re_search(r'se" value="(.*?)"', req)
client = re_search(r'client" value="(.*?)"', req)
uuid = re_search(r'captcha\?uuid=(.*?)&t=', req)
if not (sid and returl and se and uuid):
qDebug('Params not found! Retrying...')
sleep(3)
continue
res = _login(session, sid, returl, se, client,
username, password, code, uuid)
if res == 2:
parent.LogInfo.emit('[MSG]Wrong captcha! Try again!\n')
qDebug('Wrong captcha! Try again!')
continue
elif res == 1:
parent.LogInfo.emit(
'[MSG]Wrong username or password! Try again!\n'
)
qDebug('Wrong username or password! Try again!')
break
elif res == 3:
parent.LogInfo.emit(
'[MSG]Opps! You are banned for 30s...Waiting...\n'
)
qDebug('Opps! You are banned for 30s...Waiting...')
sleep(30)
continue
else:
return session
def captcha():
c = Captcha()
info = c.create_captcha()
image = os.path.join(app.config['BASE_DIR'],'static/captcha/') + info['image_name']
# 读取验证码
with open(image,'rb') as f:
image = f.read()
# 获取验证码具体字母和数字
session['captcha'] = info['captcha']
return Response(image,mimetype='jpeg')
def captcha():
from captcha import Captcha
c = Captcha()
info = c.create_captcha()
image = os.path.join(os.path.dirname(__file__),
"static/captcha") + "/" + info["image_name"]
with open(image, 'rb') as f:
image = f.read()
session['captcha'] = info["captcha"]
# print(session['captcha'])
return Response(image, mimetype="jpeg")
def captcha():
from captcha import Captcha
c = Captcha()
info = c.create_captcha()
image = os.path.join(os.path.dirname(__file__),
'static/captcha') + '/' + info['image_name']
with open(image, 'rb') as f:
image = f.read()
# 进行会话session中值的保存
session['captcha'] = info['captcha']
# print(session['captcha'])
return Response(image, mimetype='jpeg')
def get(self): randomizer = Randomizer() pattern = randomizer.get_pattern() left = randomizer.get_number() operator = randomizer.get_operator() right = randomizer.get_number() self.captcha = Captcha(pattern, left, operator, right)
async def verify_captcha(request):
try:
data = await request.json()
is_verified = verify_user_captcha(data.get('widget_id'),
data.get('input'))
if not is_verified:
captcha = Captcha()
response = JSONResponse({
'is_verified': is_verified,
'widget_id': captcha.widget_id,
'captcha_b64': captcha.b64_string
})
else:
response = JSONResponse({'is_verified': is_verified})
return response
except Exception:
response = Response('Error verifying captcha',
status_code=500,
media_type='text/plain')
return response
def __init__(self):
self.POST_DATA = {}
self.session = requests.Session()
home_response = self.session.get(HOME_URL)
dom = BeautifulSoup(home_response.content, "html.parser")
inputs = dom.find_all('input')
for input in inputs:
if 'value' in input.attrs:
self.POST_DATA[input.attrs['name']] = input.attrs['value']
else:
self.POST_DATA[input.attrs['name']] = None
self.captcha_url = dom.find(id="imgcap").attrs['src']
captcha_response = self.session.get(ROOT_URL + self.captcha_url)
captcha_file = BytesIO()
captcha_file.write(captcha_response.content)
code = Captcha(captcha_file).crack()
self.POST_DATA['txtCaptcha'] = code
class CaptchaController:
def get(self):
randomizer = Randomizer()
pattern = randomizer.get_pattern()
left = randomizer.get_number()
operator = randomizer.get_operator()
right = randomizer.get_number()
self.captcha = Captcha(pattern, left, operator, right)
def to_json(self):
self.get()
left = self.captcha.get_left()
operator = self.captcha.get_operator()
right = self.captcha.get_right()
json = '{"left":"%s", "operator":"%s", "right":"%s"}' % (left, operator, right)
return json
def __init__(self):
self.token = "Jh2044695"
self.db = self.__gen_db("./middle.db")
self.baseRange = 10
self.target = 5
self.sms = SmsHelper()
self.captcha = Captcha()
def show_captcha(url):
"""
Muetra una imagen con el captcha y devuelve el texto escrito por el usuario
:param url:
:return:
"""
from captcha import Captcha
skin = 'Estuary' if xbmc.getSkinDir() == 'skin.estuary' else 'Default'
return Captcha("Captcha.xml", sysinfo.runtime_path, skin).start(url)
def __init__(self, account, password):
# post paramenters
self.account = account
self.password = password
#request header
self.connect = ConnectHttp()
self.headers = self.connect.headers
self.captcha = Captcha(self.connect)
def __init__(self, card_id, user_list, callback, i):
threading.Thread.__init__(self)
self.url_get = 'http://hao.17173.com/gift-captcha.html?refresh=1&gift_id=%d&_=%d'
self.url_img = 'http://hao.17173.com%s'
self.url_submit = 'http://hao.17173.com/gift-qiang-%d.html'
self.card_id = card_id
self.user_list = user_list
self.callback = callback
self.captcha = Captcha()
self.i = i
webCookie = http.cookiejar.CookieJar()
cookie_handler = urllib.request.HTTPCookieProcessor(webCookie)
self.openner = urllib.request.build_opener(cookie_handler)
#proxy_handler = urllib.request.ProxyHandler({'http': 'child-prc.intel.com:913'})
#self.openner = urllib.request.build_opener(cookie_handler, proxy_handler)
self.thread_stop = False
def gen_helper(arg):
global font_path
global bg_path
global o_dir
global captcha_size
char, char_idx = arg
rotate = random.randint(-15, 15)
font_size = random.randint(700, 800)
bg_offset = (random.randint(0, 400), random.randint(0, 1000))
c = Captcha(font_path=font_path,
bg_path=bg_path,
rotate=rotate,
font_size=font_size,
bg_offset=bg_offset)
o_fname = os.path.join(
o_dir, "{0}_{1}-{2}".format(char, str(bg_offset), char_idx))
c.generate(char, o_fname=o_fname, captcha_size=captcha_size)
def captcha(request):
request.session['verified'] = False
if 'g-recaptcha-response' in request.POST:
ip = request.remote_addr
verify = Captcha.query(request.POST['g-recaptcha-response'], ip)
if verify:
request.session['verified'] = True
request.session['key'] = request.matchdict['url']
return HTTPFound(location='/getkey')
return {}
def test_post_verify_captcha():
client = TestClient(app)
captcha = Captcha()
response = client.post('/verify-captcha/',
headers={'Content-Type': 'application/json'},
json={
'widget_id': captcha.widget_id,
'input': ''.join(captcha.characters)
})
assert response.status_code == 200
class TestCaptcha(TestCase):
def setUp(self):
self.c = Captcha()
def test_solver_all_equal(self):
result = self.c.solve('1111')
self.assertEqual(4, result)
def test_solver_all_different(self):
result = self.c.solve('1234')
self.assertEqual(0, result)
def test_solver_simple_sums(self):
result = self.c.solve('1122')
self.assertEqual(3, result)
def test_loop_sum(self):
result = self.c.solve('91212129')
self.assertEqual(9, result)
def test_multiple_sums(self):
result = self.c.solve('911229')
self.assertEqual(12, result)
def test_empty_input(self):
result = self.c.solve('')
self.assertEqual(0, result)
async def new_member_handler(message: types.Message):
num = str(random.choices(range(1000, 9999))[0])
filename = f'{uuid.uuid4()}.png'
Captcha(filename, num).create()
with open(filename, 'rb') as captcha:
await bot.send_photo(message.chat.id, captcha, caption=Template.CAPTCHA.format(f'@{message["from"].username}'))
os.remove(filename)
redis_key = f'{message.chat.id}_{message["from"].id}'
redis_data = json.dumps({
"answer": num,
"kick_time": (datetime.datetime.utcnow() + datetime.timedelta(minutes=KICK_TIME_MINUTE)).strftime(FORMAT_TIME),
"username": message['from'].username
})
await redis_dispatcher.append_quque_user(redis_key, redis_data)
async def get_captcha(request):
try:
captcha = Captcha()
data = {
'widget_id': captcha.widget_id,
'captcha_b64': captcha.b64_string
}
return JSONResponse(data)
except Exception:
response = Response('Error generating captcha',
status_code=500,
media_type='text/plain')
return response
def captcha_page(session, referer, pname):
"""Takes a Session and long_id and retrieves a captcha.png file to be
processed. Returning the cracked code for its caller."""
captcha_url = 'http://buscatextual.cnpq.br/buscatextual/servlet/captcha?'\
'metodo=getImagemCaptcha'
headers = {}
headers['Accept'] = 'image/png,image/*;q=0.8,*/*;q=0.5'
headers['Accept-Encoding'] = 'gzip, deflate'
headers['Accept-Language'] = 'en-US,en;q=0.5'
headers['Connection'] = 'keep-alive'
headers['DNT'] = '1'
headers['Host'] = 'buscatextual.cnpq.br'
headers['Referer'] = referer
img_name = 'captcha_' + current_process().name + '.png'
while True:
try:
logging.info('%s-captcha_page: Getting captcha page.', pname)
headers['User-Agent'] = USER_AGENT.random
req = session.get(captcha_url, headers=headers)
except requests.exceptions.Timeout as terror:
logging.info('%s-captcha_page: Timeout: %s\nTrying again...',
pname, terror)
continue
except requests.exceptions.ConnectionError as cerror:
logging.info(
'%s-captcha_page: Connection Error: %s\nTrying '
'again...', pname, cerror)
continue
except requests.exceptions.RequestException as rerror:
logging.info(
'%s-captcha_page: Request Error: %s\nTrying '
'again...', pname, rerror)
continue
if req.status_code != 200:
continue
try:
open(img_name, 'wb').write(req.content)
code = Captcha(img_name).get_text().upper()
if len(code) == 4:
logging.info('%s-captcha_page: Right captcha length: %s',
pname, code)
return code
except Exception, ioerror:
logging.info('%s-captcha_page: %s', pname, ioerror)
continue
def __init__(self, card_id, user_list, callback, i):
threading.Thread.__init__(self)
self.url_get = 'http://hao.17173.com/gift-captcha.html?refresh=1&gift_id=%d&_=%d'
self.url_img = 'http://hao.17173.com%s'
self.url_submit = 'http://hao.17173.com/gift-qiang-%d.html'
self.card_id = card_id
self.user_list = user_list
self.callback = callback
self.captcha = Captcha()
self.i = i
webCookie = http.cookiejar.CookieJar()
cookie_handler = urllib.request.HTTPCookieProcessor(webCookie)
self.openner = urllib.request.build_opener(cookie_handler)
#proxy_handler = urllib.request.ProxyHandler({'http': 'child-prc.intel.com:913'})
#self.openner = urllib.request.build_opener(cookie_handler, proxy_handler)
self.thread_stop = False
def logout_bras(self):
#request = urllib2.Request('http://p.nju.edu.cn/portal.do?action=logout')
#urllib2.urlopen(request)
#print 'logout p.nju'
posturl = 'http://bras.nju.edu.cn/selfservice/auth.html'
cj = cookielib.LWPCookieJar()
cookie_support = urllib2.HTTPCookieProcessor(cj)
opener = urllib2.build_opener(cookie_support, urllib2.HTTPHandler)
urllib2.install_opener(opener)
urllib2.urlopen(posturl)
req_img = urllib2.Request('http://bras.nju.edu.cn/selfservice/img.html?0.0826044527348131')
res_img = urllib2.urlopen(req_img)
img = res_img.read()
f = open('code2.jpg', 'wb')
f.write(img)
f.close()
code = Captcha.Recognize('code2.jpg')
headers = {'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:14.0) Gecko/20100101 Firefox/14.0.1','Referer' : '******'}
postData = {'login_username' : self.username,'action':'login','login_password' : self.password,'code':code}
postData = urllib.urlencode(postData)
request = urllib2.Request(posturl, postData, headers)
response = urllib2.urlopen(request)
url = 'http://bras.nju.edu.cn/selfservice/?action=online'
request = urllib2.Request(url)
response = urllib2.urlopen(request)
text = response.read()
content = text.decode('UTF-8')
# 取退出必须的id
logout_id = self.get_logoutid(content)
url = 'http://bras.nju.edu.cn/selfservice/?action=disconnect&id='+str(logout_id)
request = urllib2.Request(url)
response = urllib2.urlopen(request)
text = response.read()
content = text.decode('UTF-8')
if content.find('下线成功')>-1:
print 'logout bras success'
def login_pnju(self):
posturl = 'http://p.nju.edu.cn/portal.do'
cj = cookielib.LWPCookieJar()
cookie_support = urllib2.HTTPCookieProcessor(cj)
opener = urllib2.build_opener(cookie_support, urllib2.HTTPHandler)
urllib2.install_opener(opener)
result = urllib2.urlopen(posturl)
text = result.read()
code = '0'
# 读取验证码
try:
req_img = urllib2.Request('http://p.nju.edu.cn/img.html')
res_img = urllib2.urlopen(req_img)
img = res_img.read()
f = open('code.jpg', 'wb')
f.write(img)
f.close()
# 验证码识别
code = Captcha.Recognize('code.jpg')
print 'code='+code
except:
pass
# submit login
posturl = 'http://p.nju.edu.cn/portal.do?action=login&url=http%3A%2F%2Fp.nju.edu.cn&p_login=p_login&username='******'&password='******'&code='+code+'&x=48&y=13'
request = urllib2.Request(posturl)
#print 'login...code:' + code
response = urllib2.urlopen(request)
text = response.read()
content = text.decode('utf8')
# 判断是否登录成功
if content.find('验证码错误')>-1:
print 'captcha error'
else:
print 'login p.nju success'
request = urllib2.Request('http://p.nju.edu.cn/portal.do')
response = urllib2.urlopen(request)
def captcha_show(request, name):
key = 'captcha_%s' % name
if not request.session.get(key, False):
c = Captcha()
request.session[key] = c.text
else:
c = Captcha(text=request.session.get(key))
fp_captcha = cStringIO.StringIO()
c.generate()
c.save(fp_captcha)
fp_captcha.seek(0)
res = HttpResponse(status=httplib.OK)
res['Content-Type'] = 'image/jpg'
res.write(fp_captcha.read())
return res
def test_left_operand_should_be_9(self):
captcha = Captcha(SECOND_PATTERN, 9, DUMMY_OPERATOR, DUMMY_RIGHT)
self.assertEqual("9", captcha.left_operand())
def test_string_should_be_one_plus_9(self):
captcha = Captcha(1, 1, 1, 9)
self.assertEqual("one + 9", captcha.string())
def test_right_operand_should_be_nine(self):
captcha = Captcha(SECOND_PATTERN, DUMMY_LEFT, DUMMY_OPERATOR, 9)
self.assertEqual("nine", captcha.right_operand())
def main():
argparser = argparse.ArgumentParser()
argparser.add_argument('--type', action="store", dest="type")
argparser.add_argument('-n', action="store", dest="n", type=int)
argparser.add_argument('--width', action="store", dest="width", type=int)
argparser.add_argument('--height', action="store", dest="height", type=int)
argparser.add_argument('--fontsize', action="store", dest="fontsize", type=int)
argparser.add_argument('-l', action="store", dest="length", type=int)
options = argparser.parse_args()
if options.type == None and options.n == None and options.width == None and options.height == None and options.fontsize == None and options.length == None:
print "No params given, i will use settings.ini"
props = Properties("settings.ini")
props.load()
count = props.getNumber()
rand_word = RandomWord()
rand_str = RandomString(int(props.getWordLength()))
word_type = props.getWordType()
if word_type == "natural":
i = 0
while (i < int(count)):
i = i+1
print (rand_word.getFixedLengthWord(int(props.getWordLength())))
captcha=Captcha(rand_word.getFixedLengthWord(int(props.getWordLength())), int(props.getFontSize()), int(props.getImageWidth()), int(props.getImageHeight()))
captcha.saveImage()
elif word_type == "random":
i = 0
while (i < int(count)):
i = i+1
print (rand_str.shuffle(int(props.getWordLength())))
captcha=Captcha(rand_str.shuffle(int(props.getWordLength())), int(props.getFontSize()), int(props.getImageWidth()), int(props.getImageHeight()))
captcha.saveImage()
else :
print ("word type must be random or natural")
print ("Done, generated "+props.getNumber()+" captchas")
#TODO: сделать возможность часть параматров брать из settings.ini а часть из консоли
else:
rand_word = RandomWord()
rand_str = RandomString(options.length)
word_type = options.type
if word_type == "natural":
i = 0
while (i < int(count)):
i = i+1
print (rand_word.getFixedLengthWord(options.length))
captcha=Captcha(rand_word.getFixedLengthWord(options.length, options.fontsize, options.width, options.height))
captcha.saveImage()
elif word_type == "random":
i = 0
while (i < int(count)):
i = i+1
print (rand_str.shuffle(options.length))
captcha=Captcha(rand_str.shuffle(options.length, options.fontsize, options.width, options.height))
captcha.saveImage()
else :
print ("word type must be random or natural")
print ("Done, generated "+props.getNumber()+" captchas")
def test_left_operand_should_be_nine(self):
captcha = Captcha(FIRST_PATTERN, 9, DUMMY_OPERATOR, DUMMY_RIGHT)
self.assertEqual("nine", captcha.left_operand())
def test_2_should_be_two(self):
captcha = Captcha(self.secondPattern, self.dummyLeftOperand,
self.dummyOperator, 2)
self.assertEqual('two', captcha.rightOperand.toString())
def test_4_should_be_three(self):
captcha = Captcha(self.secondPattern, 4, self.dummyOperator,
self.dummyRightOperand)
self.assertEqual('four', captcha.leftOperand.toString())
def test_get_json(self):
captcha = Captcha(1, 1, 1, 1)
output = Output(captcha)
self.assertEqual('{"operator": "+", "right": "one", "left": "1"}',
output.json())
def test_2_should_be_multiply(self):
captcha = Captcha(self.dummyPattern, self.dummyLeftOperand, 2,
self.dummyRightOperand)
self.assertEqual('*', captcha.operator.toString())
def __init__(self):
self.c = Captcha()
self.c.loadData("./iconset/")
self.is_login = False
def test_string_should_be_9_plus_one(self):
captcha = Captcha(2, 9, 1, 1)
self.assertEqual("9 + one", captcha.string())
class LoginSpider(CrawlSpider):
name = 'login'
allowed_domains = [Settings().get('HOMELINK_DOMAIN')]
start_urls = [Settings().get('HOMELINK_LOGIN_URL')]
rules = [
Rule(SgmlLinkExtractor(), follow=True)
]
def __init__(self):
self.c = Captcha()
self.c.loadData("./iconset/")
self.is_login = False
def parse(self, response):
if self.is_login:
return Request(Settings().get('HOMELINK_START_URL'), callback=self.parse_item)
else:
return self.login()
def login(self):
rid = (str)(random.random())
url = "http://beijing.homelink.com.cn/validreg.php?" + rid
urllib.urlretrieve(url, "/tmp/" + rid + ".jpg")
validateCode = self.c.crack("/tmp/" + rid + ".jpg")
yield FormRequest(url="http://beijing.homelink.com.cn/webregister/login.php?"+(str)(random.random()),
formdata={'username': Settings().get('HOMELINK_USERNAME'),
'password': Settings().get('HOMELINK_PASSWORD'),
'validateCode': validateCode,
'remember': '1',
'dologin': '******'},
callback=self.after_login)
def after_login(self, response):
# check login succeed before going on
if response.status == 200 and response.url == "http://beijing.homelink.com.cn/center/":
self.is_login = True
return Request(Settings().get('HOMELINK_START_URL'), callback=self.parse_item)
else:
print "login Failed, try again. ", response.status, response.url
return self.login()
def parse_item(self, response):
filename = response.url.split("/")[-2]
sel = Selector(response)
houses = sel.xpath('//div[@id="listData"]//div[@class="public indetail"]')
for house in houses:
item = HomelinkItem()
#style = house.xpath('@style').extract()[0]
item['hid'] = house.xpath('h3//a/@href').re(u'/sold/(.*).shtml')[0]
title = ("".join(house.xpath('h3//text()').extract())).split(' ')
item['address'] = " ".join(title[0:2])
item['house_style'] = title[2]
item['room_number'] = int(filter(lambda x:x.isdigit(),title[2]))
item['area'] = int(filter(lambda x:x.isdigit(),title[3]))
item['date'] = house.xpath('div[@class="price"]/ul/text()').extract()[0]
item['price'] = "".join(house.xpath('div[@class="priceo"]/ul/span/text()').extract() + house.xpath('div[@class="priceo"]/ul/label/text()').extract())
if item['price']:
item['price'] = int(filter(lambda x:x.isdigit(), item['price']))
item['unit_price'] = "".join(house.xpath('div[@class="priceoo"]/ul/span/text()').extract() + house.xpath('div[@class="priceoo"]/ul/label/text()').extract())
if item['unit_price']:
item['unit_price'] = int(filter(lambda x:x.isdigit(), item['unit_price']))
item['rise_rate'] = house.xpath('div[@class="priceooo"]/ul/text()').extract()[0]
item['desc'] = "".join(house.xpath('div[@class="content"]/p[@class="clearfix"]/text()').extract())
item['contact'] = house.xpath('div[@class="content"]/p[@class="clearfix"]/a/@href').extract()[0]
item['tag'] = ",".join(house.xpath('div[@class="content"]/ol/label/text()').extract())
yield item
#print hid, title, date, price, unit_price, rise_rate, desc, contact, tag
for url in sel.xpath('//div[@class="fanye"]/ul/a/@href').extract():
yield Request(Settings().get('HOMELINK_URL_PREFIX') + url, callback=self.parse_item)
class QQLogin(object):
'''login parameters'''
params = {}
connect = None
def __init__(self, account, password):
# post paramenters
self.account = account
self.password = password
#request header
self.connect = ConnectHttp()
self.headers = self.connect.headers
self.captcha = Captcha(self.connect)
def login(self):
self._initPage()
loginStatus = self._login()
if loginStatus[0] == '0' and loginStatus[1] == '0':
self._login2()
elif loginStatus[0] == '4' and loginStatus[1] == '3':
# 验证码
self._initPage()
loginStatus = self._login()
return self
def _initPage(self):
params = {'target':'self',
'style':5,
'miao_css':'m_webqq',
'appid':1003903,
'enable_qlogin':0,
'no_verifyimg':1,
's_url':'http://w.qq.com//loginproxy.html',
'f_url':'loginerroralert',
'strong_login':1,
'login_state':10,
't':'20120221001'}
req = urllib2.Request('http://ui.ptlogin2.qq.com/cgi-bin/login?'+urllib.urlencode(params),None, self.headers)
req.get_method = lambda: 'GET'
operate = self.connect.open_url(req)
inputs = InputLister()
inputs.feed(''.join(operate.readlines()))
logging.debug(inputs.items)
self.params = inputs.items
pass
def _login(self):
self.params.update({'u':self.account})
#md5(md5_3(P.p.value) + K)
if self.params.has_key('verifycode'):
self.params.update( { 'p': qmd5.qqmd5(self.password, self.params['verifycode']) })
else:
vc = self.captcha.getVerifyCode(self.account)
if vc[0] == '0':
self.params.update({ 'verifycode':vc[1] })
self.params.update({ 'p': qmd5.qqmd5(self.password, vc[1]) })
elif vc[0] == '1':
#当首次访问显示验证码地时候
vcode = self.captcha.getImgVerifyCode(self.account)
self.params.update({ 'verifycode':vcode })
self.params.update({ 'p': qmd5.qqmd5(self.password, vcode) })
pass
import random
qqActionLog = '%d-%d-%d' % (random.randint(2,9), random.randint(3,7), random.randint(2731,374463))
self.params.update({'action': qqActionLog})
self.params.update({'dumy':''})
logging.debug(self.params)
queryString = urllib.urlencode(self.params)
logging.debug(queryString)
req = urllib2.Request('http://ptlogin2.qq.com/login?'+queryString, None, self.headers);
req.get_method = lambda: 'GET'
operate = self.connect.open_url(req)
exec_rt = ''.join(operate.readlines()).decode("utf-8").encode("utf-8")
#ptuiCB('0','0','http://w.qq.com//loginproxy.html','0','登录成功！')
logging.info(exec_rt)
return eval('self._'+exec_rt.replace(';',''))
def _ptuiCB(self, signal1, signal2, url, signal3, msg):
return signal1,signal2,signal3
def _login2(self):
cookie = self.connect.getCookie('ptwebqq')
logging.debug("ptwebqq: "+cookie)
r='{"status":"online", "ptwebqq":"%s", "passwd_sig":"", "clientid":"17239126", "psessionid":null}' % cookie
params = {'r':r,
'clientid':17239126,
}
req = urllib2.Request('http://d.web2.qq.com/channel/login2',
urllib.urlencode(params)+"&psessionid=null",
self.headers)
operate = self.connect.open_url(req)
logging.debug(operate)
resp = eval(''.join(operate))
if resp['retcode'] == 0:
self.connect.ticket.update(resp['result'])
return 0
else:
return -1
class Sitedossier(object):
"""docstring for Sitedossier"""
def __init__(self, domain):
super(Sitedossier, self).__init__()
self.domain = domain
self.captcha = Captcha()
self.subset = []
def run(self):
try:
url = 'http://www.sitedossier.com/parentdomain/{0}'.format(self.domain)
r = self.get_content(url)
self.parser(r)
return list(set(self.subset))
except Exception as e:
return self.subset
def get_content(self, url):
r = http_request_get(url).text
if self.human_act(r) is True:
return r
else:
self.get_content(url)
def parser(self, response):
npage = re.search('<a href="/parentdomain/(.*?)"><b>Show', response)
if npage:
for sub in self.get_subdomain(response):
self.subset.append(sub)
nurl = 'http://www.sitedossier.com/parentdomain/{0}'.format(npage.group(1))
response = self.get_content(nurl)
self.parser(response)
else:
for sub in self.get_subdomain(response):
self.subset.append(sub)
def get_subdomain(self, response):
domain = re.compile(r'(?<=<a href\=\"/site/).*?(?=\">)')
for sub in domain.findall(response):
yield sub
def human_act(self, response):
if 'auditimage' in response or 'blacklisted' in response:
imgurl = self.get_audit_img(response)
if imgurl is not None:
ret = self.captcha.verification(imgurl)
if ret.has_key('Result'):
self.audit(ret['Result'])
return True
else:
raise Exception("captcha_verification_is_empty")
else:
raise Exception("audit_img_is_empty")
else:
return True
def audit(self, code):
payload = {'w':code}
url = 'http://www.sitedossier.com/audit'
r = http_request_post(url, payload=payload)
def get_audit_img(self, response):
auditimg = re.compile(r'(?<=<img src\=\"/auditimage/).*?(?=\?" alt="Please)')
imgurl = auditimg.findall(response)[0:]
if len(imgurl) >= 1:
imgurl = 'http://www.sitedossier.com/auditimage/{0}'.format(imgurl[0])
return imgurl
else:
return None
def __str__(self):
handler = lambda e: str(e)
return json.dumps(self, indent=2, default=handler)
def test_2_should_be_2(self):
captcha = Captcha(self.firstPattern, 2, self.dummyOperator,
self.dummyRightOperand)
self.assertEqual('2', captcha.leftOperand.toString())
class Card(threading.Thread):
def __init__(self, card_id, user_list, callback, i):
threading.Thread.__init__(self)
self.url_get = 'http://hao.17173.com/gift-captcha.html?refresh=1&gift_id=%d&_=%d'
self.url_img = 'http://hao.17173.com%s'
self.url_submit = 'http://hao.17173.com/gift-qiang-%d.html'
self.card_id = card_id
self.user_list = user_list
self.callback = callback
self.captcha = Captcha()
self.i = i
webCookie = http.cookiejar.CookieJar()
cookie_handler = urllib.request.HTTPCookieProcessor(webCookie)
self.openner = urllib.request.build_opener(cookie_handler)
#proxy_handler = urllib.request.ProxyHandler({'http': 'child-prc.intel.com:913'})
#self.openner = urllib.request.build_opener(cookie_handler, proxy_handler)
self.thread_stop = False
def run(self):
for index, user in enumerate(self.user_list):
lock.acquire()
if user['state'] > 0:
lock.release()
continue
else:
user['state'] = 1
lock.release()
user['state'] = 1
self.callback(index)
self.login(user['username'], user['password'])
user['state'] = 2
self.callback(index)
retry = 0
while not user['card_no'] and retry < 3:
img_url = self.get_captches()
result = self.identify_captchas(img_url)
user['card_no'] = self.submit_captchas(result)
retry += 1
user['state'] = 3
self.callback(index)
def stop(self):
self.thread_stop = True
def login(self, username, password):
print('\tlogin: %s ---- %s' % (username, password))
def get_captches(self):
time_stamp = int(time.time())
response = self.openner.open(self.url_get % (self.card_id, time_stamp))
data = response.read().decode()
json_obj = json.loads(data)
img_url = 'http://hao.17173.com' + json_obj["url"]
print("\tget_captchas: img: %s" % img_url)
return img_url
def identify_captchas(self, img_url):
response = self.openner.open(img_url)
image_bytes = response.read()
result = self.captcha.recognize(image_bytes)
return result
def submit_captchas(self, captcha):
values = {'verifyCode':captcha['Result']}
url_values=urllib.parse.urlencode(values).encode(encoding='UTF8')
response = self.openner.open(self.url_submit % (self.card_id), url_values)
data = response.read().decode()
json_obj = json.loads(data)
if int(json_obj['flag']) == 1:
return json_obj['cardInfo']['card_number']
else:
self.captcha.reporterror(captcha['Id'])
return ''
def test_1_should_be_one(self):
captcha = Captcha(self.secondPattern, self.dummyLeftOperand,
self.dummyOperator, 1)
self.assertEqual('one', captcha.rightOperand.toString())
def CPF(self,cpf=''):
if cpf == '':
cpf = str(raw_input('[?] CPF: ')).strip('.').strip(' ').strip('/').strip('-')
print('\n')
self.api=False
else:
self.api=True
ecount=0
while True:
session = Browser()
url = 'http://www.receita.fazenda.gov.br/aplicacoes/atcta/cpf/ConsultaPublica.asp'
url2 = 'http://www.receita.fazenda.gov.br/aplicacoes/atcta/cpf/ConsultaPublicaExibir.asp'
if not self.api:
print('[*] Connecting1...')
response = session.get_response(url)
element = session.get_bs(response.content)
if not self.api:
print(element.find('input',{'id':'viewstate'}))
#reloadImagemCaptcha();
image_url = 'http://www.receita.fazenda.gov.br/aplicacoes/atcta/cpf/captcha/' + element.find('img',{'id':'imgCaptcha'})['src'].split("/")[-1]
#image["src"].split("/")[-1]
#urlretrieve(image_url, outpath)
#viewstate = 'http://www.receita.fazenda.gov.br' + element.find('input',{'id':'viewstate'})['value']
if not self.api:
print(image_url)
captchac = Captcha()
imgfile = session.download(image_url,'rcaptcha.jpg')
try:
captcha = captchac.decode(imgfile, 30)
print('[*] AAAAAAAAAAAAAAAAAAAAAAAAAAAA')
except Exception,e:
if not self.api:
print('[!] Unrecoverable error in captcha system: %s' % str(e))
time.sleep(2)
raise Exception('[!] Unrecoverable error in captcha system: %s' % str(e))
if captcha:
if not self.api:
print("[*] Captcha cracked: " + captcha["text"] + '\n')
try:
dados = {'txtCpf':cpf,'captcha': captcha["text"]}#,'viewstate':viewstate}
response = session.post_response(url2, dados)
if u'Os caracteres da imagem não foram preenchidos corretamente' in response.content.decode("iso-8859-1", "replace"):
raise Exception('Wrong captcha')
element = session.get_bs(response.content)
data = element.findAll('span',{'class':'clConteudoDados'})
rcpf = str(data[0]).split(':')[1].split('<')[0].strip()
rnome = str(data[1]).split(':')[1].split('<')[0].strip()
rsituacao = str(data[2]).split(':')[1].split('<')[0].strip()
rdv = str(data[3]).split(':')[1].split('<')[0].strip()
if not self.api:
print('[+] CPF: %s' % rcpf)
print('[+] Nome: %s' % rnome)
print('[+] Situacao cadastral: %s' % rsituacao)
print('[+] Digito verificador: %s' % rdv)
raw_input()
else:
rdict = {'CPF': rcpf, 'Nome': rnome, 'Situacao cadastral': rsituacao, 'Digito Verificador': rdv}
return rdict
break
except Exception as e:
if e == 'Wrong captcha':
captchac.report(captcha["captcha"])
if ecount == 3:
if not self.api:
print("[!] Max attempts reached, giving up (maybe the CPF was incorrect?) ...")
raise Exception("[!] Max attempts reached, giving up (maybe the CPF was incorrect?) ...")
break
else:
ecount+=1
if not self.api:
print('\n[!] Error: %s\n[*] Trying again... (%d/3)\n' % (str(e), ecount))
def test_1_should_be_plus(self):
captcha = Captcha(self.dummyPattern, self.dummyLeftOperand, 1,
self.dummyRightOperand)
self.assertEqual('+', captcha.operator.toString())
def test_right_operand_should_be_9(self):
captcha = Captcha(FIRST_PATTERN, DUMMY_LEFT, DUMMY_OPERATOR, 9)
self.assertEqual("9", captcha.right_operand())
def test_3_should_be_minus(self):
captcha = Captcha(self.dummyPattern, self.dummyLeftOperand, 3,
self.dummyRightOperand)
self.assertEqual('-', captcha.operator.toString())
WARNING = 'WARNING'
ERROR = 'ERROR'
CRITICAL = 'CRITICAL'
def _log(lvl, msg):
if lvl != 'WARNING':
print '[{}] {}'.format(lvl, msg)
def get_info(target, cookie=''):
result = list(target._get_captcha(cookie)[1:])
result.append(cookie)
return result
config = {'log': _log, 'logger': DummyLogger, 'fontdir': 'fonts', 'tiles_path': 'tiles'}
start_time = time.time()
testme = Captcha(**config)
for xxx in range(100):
cookiex = '' if xxx % 2 else str(time.time())
data = get_info(testme, cookiex)
if xxx % 2:
data[0] += time.time()
assert not testme.captcha_verify(*data), 'Error captcha_verify 1'
else:
assert testme.captcha_verify(*data), 'Error captcha_verify 2'
assert not testme.captcha_verify(*data), 'Error captcha_verify - check_whitelist 3'
print 'Origin captcha tests ok: ', time.time() - start_time
start_time = time.time()
config['diff_mode'] = 2
testme = Captcha(**config)
for xxx in range(100):
def __init__(self, domain):
super(Sitedossier, self).__init__()
self.domain = domain
self.captcha = Captcha()
self.subset = []
def when_i_want_get_left_operand(step):
captcha = Captcha(world.pattern, world.left, world.operator, world.right)
world.actual = captcha.left_operand()
