Posts tagged "packets"

• MovementRequestMessage -> AutoBan for 2 hours

  Generally, if you want move using packets, u will notice, that without MovementCompleteMessage, after re-login, you’ll be teleported back to start position.

  And 2nd “thing”, after MovementRequestMessage, without sending MovementCompleteMessage, you can’t move anymore xD

  Fix… send MovementCompleteMessage… but if u send it too fast, after 20-30 steps u will be kicked and banned for two hours. Why?! Because it will look like you’re using SpeedHack.

  That’s why you should use 250ms+ delay for EACH CELL YOU MOVE.

  dofus bot packets
  10 months ago reblog like 9 notes
• Ruby & Binary data… My way of parsing:

  Wrote class, that help me reading binary data:

  Usage

  "\x11\x5f\x14".log # show hexdump
  "\x40\x40".readShort # & etc
  

  Code

  module NetString
    LITTLE_ENDIAN = 1
    BIG_ENDIAN = 2
  
    SYS_ENDIAN = ([42].pack('i')[0].ord == 42) ? LITTLE_ENDIAN : BIG_ENDIAN
  
    def endian
      #@endian = SYS_ENDIAN if @endian.nil?
      @endian = BIG_ENDIAN if @endian.nil?
      @endian
    end
  
    def endianess=(endian)
      unless [BIG_ENDIAN, LITTLE_ENDIAN].include? endian
        raise 'Endianess should be set with const: NetString::LITTLE_ENDIAN or NetString::BIG_ENDIAN'
        exit
      end
  
      @endian = endian
    end
  
    def endianess data
      endian
  
      if @endian != SYS_ENDIAN
        data.reverse!
      end
    end
  
    def nsRead l, endian = true
      case self
      when String
        self.force_encoding 'ASCII-8BIT' if self.encoding.to_s == 'UTF-8'
        data = slice!(0, l)
      when File, StringIO
        data = read(l)
      end
  
      unless data.bytes.to_a.size == l
        self.log "self"
        pp l
        data.log "data"
      end
  
      raise 'NetString: incorrect length data read' unless data.bytes.to_a.size == l
  
      endianess(data) if endian
      data
    end
  
    def readByte; nsRead(1, false).unpack('c').first.to_i; end ## signed
    def readUByte; nsRead(1, false).unpack('C').first.to_i; end
  
    def readBoolean; !(readByte == 0); end
  
    def readShort; nsRead(2).unpack('s').first.to_i; end ## signed
    def readUShort; nsRead(2).unpack('S').first.to_i; end
  
    def readInt; nsRead(4).unpack('l').first.to_i; end ## signed
    def readUInt; nsRead(4).unpack('L').first.to_i; end
  
    def readDouble; nsRead(8, false).unpack('G').first.to_i; end ## Double-precision float
    def readFloat; puts '----------- CHECK ME READ FLOAT -----------'; nsRead(8).unpack('g').first.to_i; end ## Single-precision float
  
    def readQuad; nsRead(8).unpack('Q').first.to_i; end
    def readLongLong; a = readInt; b = readInt; a | (b << 32); end
  
    def readBytesAsString l; nsRead(l, false); end
    def readString; str = ''; while (char = readBytesAsString(1)) != "\x00"; str << char; end; str; end
    def readUTFString; s = readShort; readBytesAsString s; end
  
    alias_method :readUnsignedByte, :readUByte
    alias_method :readUnsignedShort, :readUShort
    alias_method :readUnsignedInt, :readUInt
    alias_method :readUTF, :readUTFString
  
    def nsWrite data, endian = true
      endianess(data) if endian
  
      case self.class.to_s
      when 'String'
        concat(data)
      when 'File'
        print data
      end
  
      self
    end
  
    def writeByte data; nsWrite([data].pack('c'), false); end
    def writeUByte data; nsWrite([data].pack('C'), false); end
  
    def writeBoolean data; nsWrite([data.to_i].pack('C'), false); end
  
    def writeShort data; nsWrite([data].pack('s')); end
    def writeUShort data; nsWrite([data].pack('S')); end
  
    def writeInt data; nsWrite([data].pack('l')); end
    def writeUInt data; nsWrite([data].pack('L')); end
  
    def writeDouble; puts '----------- CHECK ME WRITE DOUBLE -----------', nsWrite([data].pack('G')); end ## Double-precision float
    def writeFloat; puts '----------- CHECK ME WRITE FLOAT -----------', nsWrite([data].pack('g')); end ## Single-precision float
  
    def writeQuad data; nsWrite([data].pack('Q')); end
  
    def writeBytesAsString data; nsWrite(data, false); end
    def writeString data; nsWrite(data + "\x00", false); end
    def writeUTFString data; writeUShort(data.size); nsWrite(data, false); end
  
    def hexed(short = false)
      f = '%02X'
      j = ' '
  
      if short
        f = '%02x'
        j = ''
      end
  
      h = bytes.to_a.collect { |c| f % c }
  
      h.join j
    end
  
    def to_ansi
      string = ''
  
      t = bytes.to_a.each do |byte|
        byte = 46 if byte < 33 or byte > 126
  
        string += '  ' + byte.chr
      end
  
      string.strip
    end
  
    def log(name = nil, short = false)
      puts rlog(name, short)
    end
  
    def rlog(name, short = false)
      name = 'DATA DUMP' if name.nil?
      pad = '-' * 25
  
      firstline = "#{pad} #{name} (#{length}) #{pad}"
      endline = '-' * firstline.length 
  
      firstline << "\n" <<
        to_ansi << "\n" <<
        hexed(short) << "\n" <<
      endline
    end
  
    def to_block(l = 50, params = {})
      l /= 2
  
      self.strip!
  
      puts "#{'-' * l} #{self} #{'-' * l}\n"
  
      params.each { |k, v| puts "#{k}: #{v}" } if params.size
      yield
  
      puts "#{'-' * (2 * l + length + 2)}"
    end
  end
  
  class String
    include NetString
  end
  
  class IO
    include NetString
  end
  
  class StringIO
    include NetString
  end
  

  Btw, it’s in beta currently, because i didn’t check float/double methods enough :)

  ruby packets binary
  10 months ago reblog like 2 notes