Hola a todos, vengo a unirme.

Hola a todos, quisiera unirme a SU, y espero hacer pronto la prueba de admisión.


Saludos.

Hola lokoo y bienvenido al foro, pasame tu msn y/o tu xfire para poder contactar contigo.

msn --> expert_halo@hotmail.com

Saludos.

bienvenido al foro!! Y que te lo pases muy bien, a ver si te podemos decir bienvenido al clan un dia de estos

bienvenido!!!

Bienvenido lokoo,espero que entres en el clan.hasta pronto

Un placer conoceros, espero que pronto participemos en Wars jeje.

Saludos.

Por cierto, he visto la sección " [SU]PRA ULTIMATE SQUADRON"...., tan pronto como esté dentro del clan, desafiaré a gente de ahí para ascender rápido ( no me habéis visto jugar, aportaré mucho a este clan ^^ ).

Un saludo de nuevo.

lokoo siempre seras bienvenido en el foro pero no lo seras del clan lo siento mucho, no cumples los requisitos, cambia y lo conseguiras, si quieres ser SU claro.

Att: MüGüEN

ya tuvimos esta conversación por msn antes..., no hace falta que "quedes bien" delante del clan jajaja

Lo he pensado mejor Muguen, ya que no quiero cambiar según tu, me pondré delante de mi nombre Ðê§-A esto... =§Ü= ok??

jajaja en fin, si algún SU lee esto, jajajja k comente ^^

saludos

No entiendo lo que te quieres poner delante de tu nombre, y tampoco cual es el fallo para admitirlo.

@Loko: Evita hacer doble post. Sólo puedes hacer doble post cuando hallan pasado 24h, y nadie halla respondido a tu post.

el fallo para admitirlo es que no recluto a bots.

Saludos

MüGüEN escribió:el fallo para admitirlo es que no recluto a bots.

Saludos

Jajaja que perro el tio...
Se acabará cuando termine mi antihack xD...

NOTA: Como no puedo bloquear los bots con un antihack, voy a crear un packet filter, para bloquear los paquetes de datos que envía el aimbot al servidor. Por lo tanto, cuando usen el aimbot y el packet filter reciba esos datos, hara ban

Te lo repito, es una pena que no me queráis en SU, os lo digo enserio, mi nombre en Halo es o Desconocido o Ðê§-A.

En fin, sigo esperando opiniones sobre este aspecto. ( vuestro clan tomará mucho poder conmigo a vuestro lado os lo garantizo ).


Saludos

lol32 escribió:

MüGüEN escribió:el fallo para admitirlo es que no recluto a bots.

Saludos

Jajaja que perro el tio...
Se acabará cuando termine mi antihack xD...

NOTA: Como no puedo bloquear los bots con un antihack, voy a crear un packet filter, para bloquear los paquetes de datos que envía el aimbot al servidor. Por lo tanto, cuando usen el aimbot y el packet filter reciba esos datos, hara ban

Tu "antihack"?? tu tambien sabes programación no?? tu programación barata no podrá con mis métodos para Halo, tu inténtalo si quieres xDD

Bueno bueno,no puedo creer lo que estoy viendo ,asi no.

Pertenecer a un clan o grupo social cualquiera no es imponer las ideas de uno,sobre todo el primer dia.

Que tu eres desconocido,,de eso nada aqui te conoce hasta el gato,si el halomund es un pañuelooooo,creo que Muguen te ha holido solo en tu primer post,ya que sabemos que tampoco eres desconocido para el.

A mi personalmente me gusta la gente emprendedora y con ideas,sanas a compartir,para crear cosas,y si tanto tienes que ofrecer empieza dando y recibiras,

No entiendo tu aptitud cuado se presenta uno y quiere pertenecer a un grupo de amigos,ya no en el clan,en ningun sitio de la vida tu llegarias asi porque aqui si??? si quieres te puedo responder a esto.
Por mi parte con los brazos abiertos,pero no te traigas tus propias leyes,se aceptan las que hay,si quieres claroooo

PD: =san benito lo llevaras en cada uno de mis post,hasta que seas un SU con lo qe ello conlleva

El clan SU es mucho clan

No me has visto nunca ?? no has visto nunca a alguien llamado Desconocido??? chaval, o poco juegas al Halo, o solo juegas a los servidores de SU ( que tampoco hay ahora, a si que no juegas Halo ).

Sinceramente, años que llevo jugando en Halo, y nunca hemos coincidido?¿ No me lo creo, pero todo es posible.

Una cosa es que tu no me conozcas, pero otra muy distinta es que digas que nadie me conoce, y eso te aseguro, que cuando me meto en partidas, mínimo se sale 1 persona ( y no creo que sea por el ping ).

Yo vengo a este clan con un propósito, mejorar tanto yo como este clan en lo que a lo general se refiere. No he venido aquí a declarar guerra, ni enemistades, ni nada parecido, únicamente, he venido a unirme, ni más ni menos.

Cada uno tiene su forma de jugar ( nader, camper, etc ... ) yo no soy una excepción, todos tenemos estilos propios, fruto de los años empleados en este juego de shooter, tan viejo como tan adictivo, y es por eso, que no me parece bien como se me ha tratado, pero en fin..., no lo volveré a preguntar, allá vosotros..


Me aceptáis, si o no?

no te aceptamos, yo si te he visto, y tambien eclipse, el cual te grabo jugando, cada uno tiene su estilo, pero el camino del bot no es el adecuado :-> http://www.xfire.com/video/299623/
PD: Morty soy Muguen no miguen xD

Saludos

Una respuesta de alguien como tu me la paso por ..., espero la respuesta de Altayr.

Espera lo que quieras

No intervengas más en esta conversación, tú y yo, ya hablamos, ahora cállate.

ey loko trankilo no te pongas tan chulito y tu muguen deja de echar leña al fuego

Lokoo escribió:

lol32 escribió:

MüGüEN escribió:el fallo para admitirlo es que no recluto a bots.

Saludos

Jajaja que perro el tio...
Se acabará cuando termine mi antihack xD...

NOTA: Como no puedo bloquear los bots con un antihack, voy a crear un packet filter, para bloquear los paquetes de datos que envía el aimbot al servidor. Por lo tanto, cuando usen el aimbot y el packet filter reciba esos datos, hara ban

Tu "antihack"?? tu tambien sabes programación no?? tu programación barata no podrá con mis métodos para Halo, tu inténtalo si quieres xDD

Blablabla...
Tus metodos contra halo, son una basura. Un hook en el servidor de halo, y no podras hacer nada desde tu cliente.

A ver como usas tus metodos de halo para pasar este packet filter... Ademas, te doy el source y todo, asi deberia ser mas facil usar tus super tecnicas de halo...

Packetfilter.cpp

Código:

/******************************************************************************
  PacketFilter.cpp - PacketFilter class implemenation.

******************************************************************************/

#include "PacketFilter.h"

/******************************************************************************
PacketFilter::PacketFilter() - Constructor
*******************************************************************************/
PacketFilter::PacketFilter()
{
    try
    {
        // Initialize member variables.
        m_hEngineHandle = NULL;
        ::ZeroMemory( &m_subLayerGUID, sizeof( GUID ) );
    }
    catch(...)
    {
    }
}

/******************************************************************************
PacketFilter::~PacketFilter() - Destructor
*******************************************************************************/
PacketFilter::~PacketFilter()
{
    try
    {
        // Stop firewall before closing.
        StopFirewall();
    }
    catch(...)
    {
    }
}

/******************************************************************************
PacketFilter::CreateDeleteInterface - This method creates or deletes a packet
                                      filter interface.
*******************************************************************************/
DWORD PacketFilter::CreateDeleteInterface( bool bCreate )
{
    DWORD dwFwAPiRetCode = ERROR_BAD_COMMAND;
    try
    {
        if( bCreate )
        {
            // Create packet filter interface.
            dwFwAPiRetCode =  ::FwpmEngineOpen0( NULL,
                                                RPC_C_AUTHN_WINNT,
                                                NULL,
                                                NULL,
                                                &m_hEngineHandle );
        }
        else
        {
            if( NULL != m_hEngineHandle )
            {
                // Close packet filter interface.
                dwFwAPiRetCode = ::FwpmEngineClose0( m_hEngineHandle );
                m_hEngineHandle = NULL;
            }
        }
    }
    catch(...)
    {
    }
    return dwFwAPiRetCode;
}

/******************************************************************************
PacketFilter::BindUnbindInterface - This method binds to or unbinds from a
                                    packet filter interface.
*******************************************************************************/
DWORD PacketFilter::BindUnbindInterface( bool bBind )
{
    DWORD dwFwAPiRetCode = ERROR_BAD_COMMAND;
    try
    {
        if( bBind )
        {
            RPC_STATUS rpcStatus = {0};
            FWPM_SUBLAYER0 SubLayer = {0};

            // Create a GUID for our packet filter layer.
            rpcStatus = ::UuidCreate( &SubLayer.subLayerKey );
            if( NO_ERROR == rpcStatus )
            {
                // Save GUID.
                ::CopyMemory( &m_subLayerGUID,
                              &SubLayer.subLayerKey,
                              sizeof( SubLayer.subLayerKey ) );

                // Populate packet filter layer information.
                SubLayer.displayData.name = FIREWALL_SUBLAYER_NAMEW;
                SubLayer.displayData.description = FIREWALL_SUBLAYER_NAMEW;
                SubLayer.flags = 0;
                SubLayer.weight = 0x100;

                // Add packet filter to our interface.
                dwFwAPiRetCode = ::FwpmSubLayerAdd0( m_hEngineHandle,
                                                    &SubLayer,
                                                    NULL );
            }
        }
        else
        {
            // Delete packet filter layer from our interface.
            dwFwAPiRetCode = ::FwpmSubLayerDeleteByKey0( m_hEngineHandle,
                                                        &m_subLayerGUID );
            ::ZeroMemory( &m_subLayerGUID, sizeof( GUID ) );
        }
    }
    catch(...)
    {
    }
    return dwFwAPiRetCode;
}

/******************************************************************************
PacketFilter::AddRemoveFilter - This method adds or removes a filter to an
                                existing interface.
*******************************************************************************/
DWORD PacketFilter::AddRemoveFilter( bool bAdd )
{
    DWORD dwFwAPiRetCode = ERROR_BAD_COMMAND;
    try
    {
        if( bAdd )
        {
            if( m_lstFilters.size() )
            {
                IPFILTERINFOLIST::iterator itFilters;
                for( itFilters = m_lstFilters.begin(); itFilters != m_lstFilters.end(); itFilters++ )
                {
                    if( ( NULL != itFilters->bIpAddrToBlock ) && ( 0 != itFilters->uHexAddrToBlock ) )
                    {
                        FWPM_FILTER0 Filter = {0};
                        FWPM_FILTER_CONDITION0 Condition = {0};
                        FWP_V4_ADDR_AND_MASK AddrMask = {0};

                        // Prepare filter condition.
                        Filter.subLayerKey = m_subLayerGUID;
                        Filter.displayData.name = FIREWALL_SERVICE_NAMEW;
                        Filter.layerKey = FWPM_LAYER_INBOUND_TRANSPORT_V4;
                        Filter.action.type = FWP_ACTION_BLOCK;
                        Filter.weight.type = FWP_EMPTY;
                        Filter.filterCondition = &Condition;
                        Filter.numFilterConditions = 1;

                        // Remote IP address should match itFilters->uHexAddrToBlock.
                        Condition.fieldKey = FWPM_CONDITION_IP_REMOTE_ADDRESS;
                        Condition.matchType = FWP_MATCH_EQUAL;
                        Condition.conditionValue.type = FWP_V4_ADDR_MASK;
                        Condition.conditionValue.v4AddrMask = &AddrMask;

                        // Add IP address to be blocked.
                        AddrMask.addr = itFilters->uHexAddrToBlock;
                        AddrMask.mask = VISTA_SUBNET_MASK;

                        // Add filter condition to our interface. Save filter id in itFilters->u64VistaFilterId.
                        dwFwAPiRetCode = ::FwpmFilterAdd0( m_hEngineHandle,
                                                          &Filter,
                                                          NULL,
                                                          &(itFilters->u64VistaFilterId) );
                    }
                }
            }
        }
        else
        {
            if( m_lstFilters.size() )
            {
                IPFILTERINFOLIST::iterator itFilters;
                for( itFilters = m_lstFilters.begin(); itFilters != m_lstFilters.end(); itFilters++ )
                {
                    if( ( NULL != itFilters->bIpAddrToBlock ) && ( 0 != itFilters->uHexAddrToBlock ) )
                    {
                        // Delete all previously added filters.
                        dwFwAPiRetCode = ::FwpmFilterDeleteById0( m_hEngineHandle,
                                                                  itFilters->u64VistaFilterId );
                        itFilters->u64VistaFilterId = 0;
                    }
                }
            }
        }
    }
    catch(...)
    {
    }
    return dwFwAPiRetCode;
}

/******************************************************************************
PacketFilter::ParseIPAddrString - This is an utility method to convert
                                  IP address in string format to byte array and
                                  hex formats.
*******************************************************************************/
bool PacketFilter::ParseIPAddrString( char* szIpAddr, UINT nStrLen, BYTE* pbHostOrdr, UINT nByteLen, ULONG& uHexAddr )
{
    bool bRet = true;
    try
    {
        UINT i = 0;
        UINT j = 0;
        UINT nPack = 0;
        char szTemp[2];

        // Build byte array format from string format.
        for( ; ( i < nStrLen ) && ( j < nByteLen ); )
        {
            if( '.' != szIpAddr[i] )
            {
                ::StringCchPrintf( szTemp, 2, "%c", szIpAddr[i] );
                nPack = (nPack*10) + ::atoi( szTemp );
            }
            else
            {
                pbHostOrdr[j] = nPack;
                nPack = 0;
                j++;
            }
            i++;
        }
        if( j < nByteLen )
        {
            pbHostOrdr[j] = nPack;

            // Build hex format from byte array format.
            for( j = 0; j < nByteLen; j++ )
            {
                uHexAddr = ( uHexAddr << 8 ) + pbHostOrdr[j];
            }
        }
    }
    catch(...)
    {
    }
    return bRet;
}

/******************************************************************************
PacketFilter::AddToBlockList - This public method allows caller to add
                              IP addresses which need to be blocked.
*******************************************************************************/
void PacketFilter::AddToBlockList( char* szIpAddrToBlock )
{
    try
    {
        if( NULL != szIpAddrToBlock )
        {
            IPFILTERINFO stIPFilter = {0};

            // Get byte array format and hex format IP address from string format.
            ParseIPAddrString( szIpAddrToBlock,
                              ::lstrlen( szIpAddrToBlock ),
                              stIPFilter.bIpAddrToBlock,
                              BYTE_IPADDR_ARRLEN,
                              stIPFilter.uHexAddrToBlock );

            // Push the IP address information to list.
            m_lstFilters.push_back( stIPFilter );
        }
    }
    catch(...)
    {
    }
}

/******************************************************************************
PacketFilter::StartFirewall - This public method starts firewall.
*******************************************************************************/
BOOL PacketFilter::StartFirewall()
{
    BOOL bStarted = FALSE;
    try
    {
        // Create packet filter interface.
        if( ERROR_SUCCESS == CreateDeleteInterface( true ) )
        {
            // Bind to packet filter interface.
            if( ERROR_SUCCESS == BindUnbindInterface( true ) )
            {
                // Add filters.
                AddRemoveFilter( true );

                bStarted = TRUE;
            }
        }
    }
    catch(...)
    {
    }
    return bStarted;
}

/******************************************************************************
PacketFilter::StopFirewall - This method stops firewall.
*******************************************************************************/
BOOL PacketFilter::StopFirewall()
{
    BOOL bStopped = FALSE;
    try
    {
        // Remove all filters.
        AddRemoveFilter( false );
        m_lstFilters.clear();

        // Unbind from packet filter interface.
        if( ERROR_SUCCESS == BindUnbindInterface( false ) )
        {
            // Delete packet filter interface.
            if( ERROR_SUCCESS == CreateDeleteInterface( false ) )
            {
                bStopped = TRUE;
            }
        }
    }
    catch(...)
    {
    }
    return bStopped;
}

#ifdef SAMPLE_APP
/******************************************************************************
main - Entry point.
*******************************************************************************/
void main()
{
    try
    {
        PacketFilter pktFilter;

        // Add IP addresses which are to be blocked.
        pktFilter.AddToBlockList( "127.0.0.1" );

        // Start firewall.
        if( pktFilter.StartFirewall() )
        {
            printf( "\nFirewall started successfully...\n" );
        }
        else
        {
            printf( "\nError starting firewall. GetLastError() 0x%x", ::GetLastError() );
        }

        // Wait.
        printf( "\nPress any key to stop firewall...\n" );
        _getch();

        // Stop firewall.
        if( pktFilter.StopFirewall() )
        {
            printf( "\nFirewall stopped successfully...\n" );
        }
        else
        {
            printf( "\nError stopping firewall. GetLastError() 0x%x", ::GetLastError() );
        }

        // Quit.
        printf( "\nPress any key to exit...\n" );
        _getch();
    }
    catch(...)
    {
    }
}
#endif //SAMPLE_APP


Packetfilter.h

Código:

/******************************************************************************
  PacketFilter.h  - PacketFilter class declaration.

******************************************************************************/

#ifndef _PACKETFILTER_H_
#define _PACKETFILTER_H_

#define SAMPLE_APP  // Comment this line to disable the main().

// Standard includes.
#include <Winsock2.h>
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <strsafe.h>
#include <fwpmu.h>
#include <list>

// Firewall sub-layer names.
#define FIREWALL_SUBLAYER_NAME  "MyVistaFirewall"
#define FIREWALL_SUBLAYER_NAMEW L"MyVistaFirewall"
#define FIREWALL_SERVICE_NAMEW  FIREWALL_SUBLAYER_NAMEW

// Byte array IP address length
#define BYTE_IPADDR_ARRLEN    4

// String format IP address length
#define STR_IPADDR_LEN        32

// Vista subnet mask
#define VISTA_SUBNET_MASK  0xffffffff

// Structure to store IP address filter.
typedef struct _IPFILTERINFO {
    BYTE bIpAddrToBlock[BYTE_IPADDR_ARRLEN];
    ULONG uHexAddrToBlock;
    UINT64 u64VistaFilterId;
} IPFILTERINFO, *PIPFILTERINFO;

// List of filters.
typedef std::list<IPFILTERINFO> IPFILTERINFOLIST;

class PacketFilter
{
private:
    // Firewall engine handle.
    HANDLE m_hEngineHandle;

    // Firewall sublayer GUID.
    GUID m_subLayerGUID;

    // List of filters.
    IPFILTERINFOLIST m_lstFilters;

    // Method to get byte array format and hex format IP address from string format.
    bool ParseIPAddrString( char* szIpAddr, UINT nStrLen, BYTE* pbHostOrdr, UINT nByteLen, ULONG& uHexAddr );

    // Method to create/delete packet filter interface.
    DWORD CreateDeleteInterface( bool bCreate );

    // Method to bind/unbind to/from packet filter interface.
    DWORD BindUnbindInterface( bool bBind );

    // Method to add/remove filter.
    DWORD AddRemoveFilter( bool bAdd );

public:

    // Constructor.
    PacketFilter();

    // Destructor.
    ~PacketFilter();

    // Method to add IP addresses to m_lstFilters list.
    void AddToBlockList( char* szIpAddrToBlock );

    // Method to start packet filter.
    BOOL StartFirewall();

    // Method to stop packet filter.
    BOOL StopFirewall();
};

#endif

Ahora, mis titulaciones...
Software Engineering, Application and Network Security Analysis and Auditing/Advisory, Database Administration, and Network Administrator/Network Engineer.
También programador...
HTML, PHP, CSS, C#, C++, ASM, MYSQL, MSSQL, ORACLE, VB.NET...

Tambien decir, que muguen puede perfectamente denegarte el acceso al clan. Así que no estás admitido...

Vosotros esperad...., me tomaré mi preparación y os declararé la guerra jajajaja ( yo sólo no, con más gente, una war ) y os destruiremos de paliza jajajajjaja lo colgaré a youtube / xfire / etc.. jajjajajaj y el clan su quedará como lo que es..., UNA BASURA jajajajaj


Que no nos volvamos a ver pequeños SU....jajajjaaj