[Обсуждение] zombie-farmer 2.3.1(Клиент для игры Зомби ферма)

[Coca-c]

я знаю в чем ошибка но не знаю как ее решить)) надо calcSig в Factory изменить на старую калькуляцию сиг
А как это сделать я хз)) в этом боте) если кто сделает кинете новый фактори?

[winston-knauf]

Цитата: Сообщение от Coca-c я знаю в чем ошибка но не знаю как ее решить)) надо calcSig в Factory изменить на старую калькуляцию сиг А как это сделать я хз)) в этом боте) если кто сделает кинете новый фактори?

Уже лучше будем надеется что кто то решит проблему!

[greyzza]

Цитата: я знаю в чем ошибка но не знаю как ее решить)) надо calcSig в Factory изменить на старую калькуляцию сиг А как это сделать я хз)) в этом боте) если кто сделает кинете новый фактори?

а точно это ТЫ знаешь в чем проблема? даже слова не поменял)
делать нужно следующее:
открываем factory
меняем функцию def generate_sig(self):
на это

Цитата: def generate_sig(self): sig = self.session_key + str(self.server_time) + self.auth_key return self.md5hash(sig + self.salt(sig))

пробуем

я этим ботом не пользуюсь поэтому проверить не могу, так чисто по наитию

[wiz68ard]

Цитата: пробуем

а ссылки не нужно менять которые ты выложил в теме зомбот?

[greyzza]

Цитата: а ссылки не нужно менять которые ты выложил в теме зомбот?

пока по старым работает

[Юрий)))]

Цитата: Сообщение от greyzza а точно это ТЫ знаешь в чем проблема? даже слова не поменял) делать нужно следующее: открываем factory меняем функцию def generate_sig(self): на это пробуем я этим ботом не пользуюсь поэтому проверить не могу, так чисто по наитию

можете пожалуйста записать это в factory и скинуть его?)не получается самому это сделать

[valenso1997]

Цитата: Сообщение от greyzza а точно это ТЫ знаешь в чем проблема? даже слова не поменял) делать нужно следующее: открываем factory меняем функцию def generate_sig(self): на это пробуем я этим ботом не пользуюсь поэтому проверить не могу, так чисто по наитию

не особо работает, ну или я кривой прост

# -*- coding: utf-8 -*-

import json
import logging
import hashlib

from engine.salt import salt_parser
from engine.context import context
from engine.helper import obj2dict

logger = logging.getLogger(__name__)


class Factory(object):
def __init__(self, uid, auth_key, master):

self.uid = uid
self.session_key = None
self.auth_key = auth_key
self.client_version = 1451460264
self.server_time = 0
self.parsed_salt = None
self.master = master
self.redirect = None

def generate_sig_data(self, data):
data = obj2dict(data)
data = self.create_data_value(data)
crc = self.generate_crc(data)
return dict(data=data, crc=crc)

@staticmethod
def md5hash(string):
m = hashlib.md5()
m.update(string.encode(u'utf-8'))
return m.hexdigest()

def salt(self, string):
result = str(len(string)) + self.md5hash(string + 'stufff...')
salt13 = str(len(string) * 17 + 13)
result += self.md5hash(salt13 + str(len(string)) + str(len(salt13)))
result += str(reduce(lambda res, _: res + (ord(_) & 250), string, 0))
return result

def generate_crc(self, string):
return self.md5hash(string + self.salt(string))

def get_external_salt(self):
while not self.parsed_salt:
key = self.session_key.split(':')[1]
return salt_parser.generate_signature(key, self.redirect)

def generate_sig(self):
sig = self.session_key + str(self.server_time) + self.auth_key
return self.md5hash(sig + self.salt(sig))

actions = {
'1': lambda x: x + x,
'2': lambda x: x.replace('0', '1'),
'3': lambda x: x[: len(x)/2],
'4': lambda x: x[:: -1],
'5': lambda x: str(len(x) * 13),
'6': lambda x: x.upper(),
'7': lambda x: x.lower(),
'8': lambda x: x + context.account.salt_loader_url
}

if not self.parsed_salt:
self.parsed_salt = self.get_external_salt()

sig += reduce(lambda res, x: actions.get(x)(res), self.parsed_salt, sig)
return self.md5hash(sig)

def generate_auth(self):
auth = str(self.server_time) + self.auth_key
auth += self.salt(auth)
return self.md5hash(auth)

def create_data_value(self, data):

message_types = {
'TIME': ['auth', 'type', 'clientVersion', 'user', 'id', 'key'],
'START': ['id', 'sig', 'clientTime', 'serverTime', 'info', 'type', 'user', 'ad', 'lang'],
'EVT': ['user', 'type', 'id', 'sig', 'events']
}
data_keys_order = message_types.get(data['type'], [])

data['user'] = str(self.uid)
data['id'] = self.server_time
data['sig'] = self.generate_sig() if self.session_key else ''
data['auth'] = self.generate_auth() if not self.session_key else ''
data['clientVersion'] = self.client_version

data_value = dict((key, data[key]) for key in data_keys_order if data.get(key, 'unknown') != 'unknown')
self.server_time += 1

return json.dumps(data_value, separators=(',', ':'), ensure_ascii=False, encoding='utf-8')

[wiz68ard]

Цитата: пробуем

все работает, спасибо тебе спаситель)

[greyzza]

Цитата: не особо работает, ну или я кривой прост

видимо не особо прямой)
я не знаю как там у вас по версиям насколько актуален будет этот [Ссылки могут видеть только зарегистрированные пользователи. ]
у меня какой был тот и посмотрел, но смысл понятен как нужно сделать

[wiz68ard]

ребят не надо просто копировать отсюда текст и вставлять в фактори, пропадает пробел, после self.auth_key ставьте ентер

[Юрий)))]

Цитата: Сообщение от greyzza видимо не особо прямой) я не знаю как там у вас по версиям насколько актуален будет этот [Ссылки могут видеть только зарегистрированные пользователи. ] у меня какой был тот и посмотрел, но смысл понятен как нужно сделать

Спасибо тебе большое)))все работает

Добавлено через 20 минут

Цитата: Сообщение от greyzza видимо не особо прямой) я не знаю как там у вас по версиям насколько актуален будет этот [Ссылки могут видеть только зарегистрированные пользователи. ] у меня какой был тот и посмотрел, но смысл понятен как нужно сделать

можете дать какой-то файл для реанимирования вашего бота ZomBot_by_greyzza?

[greyzza]

Цитата: можете дать какой-то файл для реанимирования вашего бота ZomBot_by_greyzza?

а зачем он вам? вы же фермером пользуетесь, а вообще если файлы не скомпилированы можете просто открыть message_factory там есть две функции calcSig, так вот которая нижняя просто переименуйте ее например в calcSig2 этого будет достаточно

[wiz68ard]

Цитата: вы же фермером пользуетесь

я бы тоже перешел на зомбот если бы он у меня был бы) а то ты ссылки удаляешь быстро, скачать не успеваю)

[B gpoBa]

Спасибо ребятам что нашли и исправили проблему. Я вот тут для совсем ленивых выложу:
zombie-farmer 2.1.7\vk\message_factory.py

PHP код:

# coding=utf8
from read_swf import swf2functions
import urllib2
import hashsum
import json
import collections
import os
import subprocess
import _subprocess
import random
import logging

logger = logging.getLogger(__name__)


def __saltFunction(string):
    result = ""
    # from classWithGo
    result += str(len(string)) + hashsum._md5hash(string + "stufff...")
    salt13 = str(len(string) * 17 + 13) #то , что заменили
    #salt13 = str(len(string) * 13)  # from main.initialize
    salt2 = hashsum._md5hash(salt13 + str(len(string))+ str(len(salt13))) #то , что заменили
    #salt2 = hashsum._md5hash(salt13 + str(len(salt13)) + str(len(string)))
    result += salt2
    characterSum = 0  # calc sum of byte codes in a string
    for i in range(0, len(string)):
        characterSum += (ord(string[i]) & 250) #то , что заменили
        #characterSum += (ord(string[i]) & 255)
    result += str(characterSum)
    return result


def calcCRC(string):
    return hashsum._md5hash(string + __saltFunction(string))

def calcSig(sessionKey, requestId, authKey):

    Sig = sessionKey + str(requestId) + authKey
    Sig += __saltFunction(Sig)
    Sig = hashsum._md5hash(Sig)
    return Sig


def calcAuth(requestId, authKey):
    auth = str(requestId) + authKey
    auth += __saltFunction(auth)
    sig = hashsum._md5hash(auth)
    return sig


class Session():
    '''
    This class represents session data needed
    to authenticate and sign messages
    '''
    def __init__(self, user_id, auth_key, client_version=1362084734,
                 session_key=None):
        self.__user_id = user_id          # vk user id
        self.__session_key = session_key  # session key from TIME request
        self.__auth_session_key = None    # key from TIME response
        self.__auth_key = auth_key        # auth key from vk.com flashvars
        self.CLIENT_VERSION = client_version

    def getUserId(self):
        return self.__user_id

    def getSessionKey(self):
        return self.__session_key

    def setSessionKey(self, session_key):
        self.__session_key = session_key

    def getAuthKey(self):
        return self.__auth_key

    def set_auth_key(self, auth_key):
        self.__auth_key = auth_key

    def getAuthSessionKey(self):
        return self.__auth_session_key


class Factory():
    '''
    This class will be used to generate signed messages
    '''
    def __init__(self, session, base_request_id=None):
        if base_request_id is None:
            base_request_id = _getInitialId()
        self.__session = session
        assert isinstance(self.__session, Session)
        self.BASE_REQUEST_ID = base_request_id  # "magick" initial value
        self.__request_id = self.BASE_REQUEST_ID

    def createRequest(self, data, data_keys_order=None):
        request_data = {}
        request_data['data'] = self.__createDataValue(data, data_keys_order)
        request_data['crc'] = calcCRC(request_data['data'])
        return Request(request_data)
    '''
    def calcSig(self,sessionKey, requestId, authKey):
        postfix = sessionKey.split(':')[1]
        if not hasattr(self,'postfix') or self.postfix != postfix:
            self.postfix = postfix
            url = base_redirect_url+'/salt'
            #logger.info('Getting %s?postfix=%s'%(url,postfix))
            opener = urllib2.build_opener()
            response = opener.open(url, 'postfix='+postfix, timeout=8)
            if response:
                content = response.read()
                response.close()
            else:
                raise GameError("Cannot load salt swf")
            self.functions = swf2functions(content,postfix)
        sig = sessionKey + str(requestId) + authKey
        saltFunction_sig = sig
        for f in self.functions:
            saltFunction_sig = f(saltFunction_sig)
        sig += saltFunction_sig
        sig = hashsum._md5hash(sig)
        return sig
    '''
    def calcSig(self, sessionKey, requestId, authKey):
        sig = sessionKey + str(requestId) + authKey
        result = str(len(sig)) + hashsum._md5hash(sig + "stufff...")
        salt13 = str(len(sig) * 17 + 13) 
        result += hashsum._md5hash(salt13 + str(len(sig))+ str(len(salt13)))
        result += str(reduce(lambda res, _: res + (ord(_) & 250), sig, 0))
        sig += result
        sig = hashsum._md5hash(sig)
        return sig

    def __createDataValue(self, data, data_keys_order):
        if data_keys_order is None:
            data_keys_order = _getDataKeyOrder(data['type'])
        datacopy = data.copy()
        datacopy['user'] = str(self.__session.getUserId())
        datacopy['id'] = self.__request_id
        datacopy['sig'] = ''
        datacopy['auth'] = ''
        datacopy['clientVersion'] = self.__session.CLIENT_VERSION
        data_value = collections.OrderedDict()
        for key in data_keys_order:
            if key in datacopy:
                data_value[key] = datacopy[key]
        message_type = datacopy['type']
        if message_type == 'START':
            info_keys = ["uid", "bdate", "country", "first_name",
                         "sex", "city", "last_name"]
            data_value['info'] = collections.OrderedDict()
            for info_key in info_keys:
                if info_key in datacopy['info']:
                    data_value['info'][info_key] = datacopy['info'][info_key]
        self.__addSigOrAuth(data_value)
        result = json.dumps(data_value, separators=(',', ':'),
                            ensure_ascii=False, encoding="utf-8")
        self._generateRequestId()
        return result

    def __addSigOrAuth(self, objectData):
        sessionKey = self.__session.getSessionKey()
        auth_key = self.__session.getAuthKey()
        authSessionKey = self.__session.getAuthSessionKey()

        if sessionKey is not None:
            objectData["sig"] = self.calcSig(sessionKey, self.__request_id,
                                        auth_key)
        else:
            objectData["auth"] = calcAuth(self.__request_id, auth_key)
            if authSessionKey is not None:
                objectData["key"] = authSessionKey
        return objectData

    def _generateRequestId(self):
        self.__request_id += 1

    def setRequestId(self, request_id):
        self.__request_id = request_id

    def _getSessionKey(self):
        return self.__session.getSessionKey()

    def setSessionKey(self, session_key):
        self.__session.setSessionKey(session_key)

    def set_auth_key(self, auth_key):
        self.__session.set_auth_key(auth_key)

class Request():
    '''
    This class represents a POST body ready to be send via HTTP
    '''
    def __init__(self, data):
        self.__data = data

    def __str__(self):
        return str(self.__data)

    def getData(self):
        return self.__data

    def send(self, connection):
        '''
        Sends request data to server,
        handles redirect
        Returns response as dict
        '''
        response = self.send_request_get_response(connection)
        
        global base_redirect_url
        response = self.send_request_get_response(connection)
        if 'redirect' in response:
            #with open("sig\\bin\\url.txt",'wt') as f:
            #    f.write(response['redirect'])
            base_redirect_url = response['redirect']
            server_url = response['redirect'] + '/go'
            connection.setUrl(server_url)        
        
        if 'cmd' in response:
            if response['cmd'] == 'REDIRECT':
                # send request again with new url
                response = self.send_request_get_response(connection)
            elif response['cmd'] == 'ERR':
                error_msg = response["msg"]
                logger.error(error_msg)
                # TODO send error to the game server
                open('error_log.txt','a').write("Connection: " + str(self.getData())+'\nResponse: '+str(response)+'\n\n')
                logger.info("Connection : " + str(self.getData()))
                logger.info("Response : " + str(response))
                raise GameError("Game server returned error: " + error_msg)
        return response

    def send_request_get_response(self, connection):
        return Response(connection.sendRequest(self.getData())).getDict()


class GameError(Exception): pass


class Response():
    '''
    This class represents a response
    '''
    def __init__(self, response_string):
        if '$' in response_string:
            crc, response = response_string.split("$", 1)
            if(calcCRC(response) != crc):
                raise ValueError("CRC is invalid: " + crc)
        else:
            response = response_string
        self.__response = json.loads(response)

    def getDict(self):
        return self.__response


def _getInitialId():
    '''
    flash.utils.getTimer() called to get initial request id.
    http://help.adobe.com/en_US/FlashPlatform/reference/
    actionscript/3/flash/utils/package.html#getTimer()
    varies randomly from 40 to 60
    '''
    random.seed()
    return random.randrange(40, 60)


def _getDataKeyOrder(message_type):
    keys = []
    if message_type == 'TIME':
        keys = ['auth', 'type', 'clientVersion', 'user',  'id', 'key' ]
    if message_type == 'START':
        keys = [
            'id',
            'sig',
            'clientTime',
            'serverTime',
            'info',
            'type',
            'user',
            'ad',
            'lang',
        ]
    if message_type == 'EVT':
        keys = [
            'user',
            'type',
            'id',
            'sig',
            'events'
        ]
    return keys 


zombie-farmer 2.3.2\engine\factory.py

PHP код:

# -*- coding: utf-8 -*-

import json
import logging
import hashlib

from engine.salt import salt_parser
from engine.context import context
from engine.helper import obj2dict

logger = logging.getLogger(__name__)


class Factory(object):
    def __init__(self, uid, auth_key, master):

        self.uid = uid
        self.session_key = None
        self.auth_key = auth_key
        self.client_version = 1451460264
        self.server_time = 0
        self.parsed_salt = None
        self.master = master
        self.redirect = None

    def generate_sig_data(self, data):
        data = obj2dict(data)
        data = self.create_data_value(data)
        crc = self.generate_crc(data)
        return dict(data=data, crc=crc)

    @staticmethod
    def md5hash(string):
        m = hashlib.md5()
        m.update(string.encode(u'utf-8'))
        return m.hexdigest()

    def salt(self, string):
        result = str(len(string)) + self.md5hash(string + 'stufff...')
        salt13 = str(len(string) * 17 + 13)
        result += self.md5hash(salt13 + str(len(string)) + str(len(salt13)))
        result += str(reduce(lambda res, _: res + (ord(_) & 250), string, 0))
        return result

    def generate_crc(self, string):
        return self.md5hash(string + self.salt(string))

    def get_external_salt(self):
        while not self.parsed_salt:
            key = self.session_key.split(':')[1]
            return salt_parser.generate_signature(key, self.redirect)

    def generate_sig(self):
        sig = self.session_key + str(self.server_time) + self.auth_key
        return self.md5hash(sig + self.salt(sig))    

        actions = {
            '1': lambda x: x + x,
            '2': lambda x: x.replace('0', '1'),
            '3': lambda x: x[: len(x)/2],
            '4': lambda x: x[:: -1],
            '5': lambda x: str(len(x) * 13),
            '6': lambda x: x.upper(),
            '7': lambda x: x.lower(),
            '8': lambda x: x + context.account.salt_loader_url
        }

        if not self.parsed_salt:
            self.parsed_salt = self.get_external_salt()

        sig += reduce(lambda res, x: actions.get(x)(res), self.parsed_salt, sig)
        return self.md5hash(sig)

    def generate_auth(self):
        auth = str(self.server_time) + self.auth_key
        auth += self.salt(auth)
        return self.md5hash(auth)

    def create_data_value(self, data):

        message_types = {
            'TIME': ['auth', 'type', 'clientVersion', 'user',  'id', 'key'],
            'START': ['id',  'sig', 'clientTime', 'serverTime', 'info', 'type', 'user', 'ad', 'lang'],
            'EVT': ['user', 'type', 'id', 'sig', 'events']
        }
        data_keys_order = message_types.get(data['type'], [])

        data['user'] = str(self.uid)
        data['id'] = self.server_time
        data['sig'] = self.generate_sig() if self.session_key else ''
        data['auth'] = self.generate_auth() if not self.session_key else ''
        data['clientVersion'] = self.client_version

        data_value = dict((key, data[key]) for key in data_keys_order if data.get(key, 'unknown') != 'unknown')
        self.server_time += 1

        return json.dumps(data_value, separators=(',', ':'), ensure_ascii=False, encoding='utf-8') 


[Юрий)))]

Цитата: Сообщение от greyzza а зачем он вам? вы же фермером пользуетесь, а вообще если файлы не скомпилированы можете просто открыть message_factory там есть две функции calcSig, так вот которая нижняя просто переименуйте ее например в calcSig2 этого будет достаточно

этот файл к сожалению скомпелирован((

Добавлено через 34 минуты

Цитата: Сообщение от greyzza а зачем он вам? вы же фермером пользуетесь, а вообще если файлы не скомпилированы можете просто открыть message_factory там есть две функции calcSig, так вот которая нижняя просто переименуйте ее например в calcSig2 этого будет достаточно

фермер не умеет стучать в туковые постройки..а ваш умеет