Hola gente!!
Como va todo?
Bueno, me propuse como fin levantar la actividad de este subforo que realmente tiene muchísimo potencial y trata de un tema súmamente interesante y de gran importancia en la actualidad.

Para esto, necesito a todos ustedes, los que cada vez que ven un texto cifrado, un hash o una imagen sospechosa, les pica el bicho de la curiosidad y quieren saber que hay detrás de esa maraña de caracteres sin orden aparente.

Entonces, se me ocurrió comenzar un taller para que todos los que estén interesados, se apunten, aporten sus conocimientos y aprendan nuevas cosas, el fin de este taller sería crear un algoritmo nuevo, optimizarlo y hacerle criptoanálisis para probar su seguridad.
Lo único que hace falta definir, es sobre que campo de la criptografía nos vamos a desarrollar:
Criptografía asimétrica?
Criptografía simétrica?
Hashes?
Esteganografía?

Es importante que digan que algoritmo les interesa, aparte de ponerlo en la encuesta y aclarar si pueden leer textos en inglés.

Bueno, escucho sus opiniones y sus aportes.

Muchas gracias a todos!
Un abrazo
APOKLIPTICO

Quiénes se han anotado:
- APOKLIPTICO (Simétrico) Inglés: Si.
- Debci (????) Inglés: ????.
- Freeze. (Simétrico) Inglés: Si.
- 16BITBoy. (Hash) Inglés: ???
- MasterPunk (Asimétrico) Inglés: Si.
- Liena. (Asimétrico) Inglés: ???
- Bomba1990. (Asimétrico) Inglés: ???
- Raul338 (Asimétrico) Inglés: Si.
- [D4N93R] (Esteganografía) Inglés:Si.
- WestOn (Asimétrico) Inglés: Si.
- Braulio-- (Hash) Inglés: Si.

Perdón Vertex, pero no sabía si ponerlo ak o en Progamacion C/C++.

El problema es el siguiente: Estoy compilando ettercap-ng bajo mingw32, compiló perfecto con un par de warnings que si el programa despues no funciona bien, las resolveré pero por ahora compila bien, el problema es cuando quiero linkearlo.
Me pide un "libnet.dll.a" yo tengo uno llamado "libnet.a" lo copié y le puse "libnet.dll.a", pero obviamente eso no resolvió el problema.
Me tira un montón de Undefined references, específicamente a estas funciones:

../libnet/lib/libnet.dll.a(libnet_resolve.o):libnet_resolve.c:(.text+0x5da): undefined reference to `PacketGetNetInfoEx'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0xdf): undefined reference to `PacketSetBuff'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0xf4): undefined reference to `PacketGetNetType'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x262): undefined reference to `PacketSetHwFilter'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x289): undefined reference to `PacketAllocatePacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x2dc): undefined reference to `PacketInitPacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x2f9): undefined reference to `PacketSendPacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x30e): undefined reference to `PacketFreePacket'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x56d): undefined reference to `SendARP@16'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x597): undefined reference to `GetAdaptersInfo@8'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x5c5): undefined reference to `GetAdaptersInfo@8'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x627): undefined reference to `SendARP@16'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x6d6): undefined reference to `GetIpNetTable@12'
../libnet/lib/libnet.dll.a(libnet_link_win32.o):libnet_link_win32.c:(.text+0x72b): undefined reference to `GetIpNetTable@12'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x521): undefined reference to `PacketGetNetType'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x60d): undefined reference to `PacketAllocatePacket'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x660): undefined reference to `PacketInitPacket'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x67d): undefined reference to `PacketSendPacket'
../libnet/lib/libnet.dll.a(libnet_write.o):libnet_write.c:(.text+0x692): undefined reference to `PacketFreePacket'
 

Alguien me podría aclarar un poco esto?
Gracias!

Hola gente, como va todo, hoy les traigo algo que realmente a muchos les va a interesar.

Muchos ya han escuchado la nueva tecnología que permite utilizar la capacidad de procesamiento de la GPU, para hacer cálculos matemáticos de alta complejidad esto tiene el nombre de GPGPU (General Purpose Graphic Processing Unit). Para esto existen varias tecnologías, Nvidia sacó su CUDA (Compute Unified Device Architecture) y Ati sacó su FireStream. También existen diversos lenguajes que se han creado ad-hoc para optimizar el acceso a esta capacidad como Brook+, CAL y algunas librerías para gráficos de juegos como PhysX y Bullet.

Pero sin embargo, hay una tecnología que a mi opinion va a ser el futuro del GPGPU, estoy hablando claramente del OpenCL una api que cross-platform que permite utilizar tanto Stream como Cuda y en caso de que ninguna de las dos esté disponible, utilizar la CPU.

Es por esto que me puse a analizar la capacidad de cálculo de las últimas placas de Nvidia y de Ati.
Para esto, utilizo el FLOPS (Operación de coma flotante por segundo) como unidad de medida.

Para hacer el cálculo de la capacidad de cálculo utilizo esta fórmula:
[Stream/CUDA cores] * 2 * [GPU clock] = Capacidad de cálculo en MFLOPS.

Tomo entonces distintas placas y las comparo:
Nvidia Geforce GTX 480 (La última de Nvidia) = 672 GFLOPS.
Nvidia Geforce GTX 295 (La última del ensamblador XFX) = 553 GFLOPS.
Ati HD4850 (La que tengo yo XD) = 1040 GFLOPS.
Ati HD5970 (La última de ATI) = 4640 GFLOPS (!).
Ati HD5970 Black Edition Limited (La última del ensamblador XFX = 5440 GFLOPS (!!!)

Ahora, claramente podemos ver que las Ati tienen una capacidad de procesamiento mucho mayor a las Nvidia en cuanto a GPGPU.

Ustedes que piensan?
Un abrazo
APOKLIPTICO

Hola gente, como va todo, hoy estaba mirando el certificado de una página y me di cuenta que utiliza como algoritmo de cifrado RC4, osea que debe de ser una combinación RSA-RC4, se envía mediante criptografía asimétrica la clave simétrica y esa es la que sutiliza para cifrar los mensajes que van y vienen.
Ahora, siendo que el algoritmo efectivo con el cual se cifran los datos es RC4 y todos sabemos que si se tienen suficientes IVs de dicho algoritmo, se puede llegar a conseguir la clave y efectivamente descifrar los datos como vimos en el algoritmo WEP.
Esto no se podría utilizar para crackear la clave RC4 de un canal seguro TLS?

Un abrazo
APOKLIPTICO

Hola gente, como va todo? Hoy les traigo dos pedazos de software que realmente les van a sacar las papas del fuego en más de una ocasión.
El primero es cryptool 1.4.3, trae numerosas opciones, ya sea de cifrar/descifrar en varios algoritmos nuevos y antiguos, varios criptoanálisis distintos como análisis de frecuencias, entropía, etc. y por último varios tutoriales educativos sobre distintos algoritmos famosos como RSA.



Por otro lado, tenemos a la nueva version de Cryptool 2.0, aún en Beta.


Esta versión introduce unos nuevos cambios, primero la capacidad de incorporar algoritmos como plugins y por otro lado, una visión más gráfica de cada algoritmo, pudiendo incorporar compuertas lógicas, contadores, e incluso crackeadores.

En mi opinión, a la versión 2.0 todavía le falta trabajo y yo la verdad no soy muy fanático de los programas con GUIs demasiado pesados, pero aún asi, permite ver de manera muy clara todos los algoritmos.

Bueno, espero que les guste, les dejo la página para que los puedan descargar.
http://www.cryptool.org/

Un abrazo
APOKLIPTICO

Hola gente del foro.
Bueno, como veo que mi post anterior no tuvo respuestas, quizas debería hacer un approach mas focalizado en cuanto a mis preguntas.
Estuve leyendo sobre los últimos avances a los ataques sobre WPA+TKIP (Beck-Tews, Ohigashi-Morii attack) y sobre los ya existentes ataques sobre WEP y el algoritmo RC4 (FMS, KOREK, PTW, Vaudenay-Vuagnoux).
Tengo este diagrama:


El tema es que este diagrama da cierta ambigüedad a partes del algoritmo.
1) La "Master key" es la clave WPA (la de 8-63 bytes que se escribe en el setup del router) o la pairwise master key (PMK) que es la clave WPA pasada por el PBKDF2???

2) De donde se sacan la MIC key y la encryption key??? del PBKDF2??? donde están los 64 bits restantes (PBKDF2 = 256 bits: encryption key 128 bits + MIC key 64 bits = 192 bits)???

3) El algoritmo de "hash()" que se da con el IV del RC4 y la encryption key, se hace con cada paquete?? Cual es este algoritmo? MD5? alguno creado ad-hoc?.

Por favor, si alguien puede responder aunque sea una de estas preguntas o mostrarme algún lugar explicativo del algoritmo TKIP, estaría muy agradecido.

Hola gente, estoy pensando en una posible implementación que podría reducir el tiempo y los IVs necesarios para crackear un clave WEP y potencialmente dar un paso más hacia el crackeo del WPA+TKIP.
Pero tengo un par de preguntas al respecto sobre el algoritmo.
1) Que algoritmo (Hash supongo) se utiliza para obtener de la clave WPA la key para luego generar el keystream del RC4?
2.a) Si yo tuviese hipotéticamente suficientes keystreams descifrados con el nuevo método derivado del chop-chop (.xor), podría llegar a conseguir el key del RC4?
2.b) Si pudiese conseguir este key, podría entonces utilizarlo para inyectar paquetes indefinidamente? o ahí entra en juego el key renewal del WPA?.
3) Hay algún lugar donde esté bien explicado el algoritmo WPA+TKIP, como existe para el NTFS la página NTFS.org?
Muchas gracias.
Un abrazo
APOKLIPTICO

Hola gente, como va todo? Acabo de compilar un programa de prueba que utiliza OpenCL. OpenCL es una plataforma que unifica el GPGPU, realmente me pareció muy buena, el tema es que yo solo tengo una Ati HD4850, no tengo ninguna Nvidia para probar, alguien podría hacerme el favor?? Osea, en definitiva lo que necesitaría es el vendor ID de nvidia para agregarlo al programa, una vez que haga esto, se puede adaptar para que funcione con ambas plataformas! No es genial?.

Bueno este es el código en cuestion, se basa en un template de el SDK de Ati Stream modificado, este es el código en cuestión:

main.cpp:

#include "main.hpp"
std::string
convertToString(const char *filename)
{
    size_t size;
    char*  str;
    std::string s;
 
    std::fstream f(filename, (std::fstream::in | std::fstream::binary));
 
    if(f.is_open())
    {
        size_t fileSize;
        f.seekg(0, std::fstream::end);
        size = fileSize = f.tellg();
        f.seekg(0, std::fstream::beg);
 
        str = new char[size+1];
        if(!str)
        {
            f.close();
            return NULL;
        }
 
        f.read(str, fileSize);
        f.close();
        str[size] = '\0';
 
        s = str;
        delete[] str;
        return s;
    }
    else
    {
        std::cout << "\nFile containg the kernel code(\".cl\") not found. Please copy the required file in the folder containg the executable.\n";
        exit(1);
    }
    return NULL;
}
int
initializeHost(void)
{
    width               = 102400;
    output                = NULL;
 
    /////////////////////////////////////////////////////////////////
    // Allocate and initialize memory used by host
    /////////////////////////////////////////////////////////////////
    cl_uint sizeInBytes = width * sizeof(cl_uint);
 
    output = (cl_uint *) malloc(sizeInBytes);
    if(output == NULL)
    {
        std::cout<<"Error: Failed to allocate output memory on host\n";
        return 1;
    }
 
    return 0;
}
int
initializeCL(bool UseGPU)
{
    cl_int status = 0;
    size_t deviceListSize;
 
    /*
     * Have a look at the available platforms and pick either
     * the AMD one if available or a reasonable default.
     */
 
    cl_uint numPlatforms;
    cl_platform_id platform = NULL;
    status = clGetPlatformIDs(0, NULL, &numPlatforms);
    if(status != CL_SUCCESS)
    {
        std::cout << "Error: Getting Platforms. (clGetPlatformsIDs)\n";
        return 1;
    }
 
    if(numPlatforms > 0)
    {
        cl_platform_id* platforms = new cl_platform_id[numPlatforms];
        status = clGetPlatformIDs(numPlatforms, platforms, NULL);
        if(status != CL_SUCCESS)
        {
            std::cout << "Error: Getting Platform Ids. (clGetPlatformsIDs)\n";
            return 1;
        }
        for(unsigned int i=0; i < numPlatforms; ++i)
        {
            char pbuff[100];
            status = clGetPlatformInfo(
                        platforms[i],
                        CL_PLATFORM_VENDOR,
                        sizeof(pbuff),
                        pbuff,
                        NULL);
            if(status != CL_SUCCESS)
            {
                std::cout << "Error: Getting Platform Info.(clGetPlatformInfo)\n";
                return 1;
            }
            platform = platforms[i];
            if(!strcmp(pbuff, "Advanced Micro Devices, Inc."))
            {
                break;
            }
        }
        delete platforms;
    }
 
    if(NULL == platform)
    {
        std::cout << "NULL platform found so Exiting Application." << std::endl;
        return 1;
    }
 
    /*
     * If we could find our platform, use it. Otherwise use just available platform.
     */
    cl_context_properties cps[3] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0 };
 
    /////////////////////////////////////////////////////////////////
    // Create an OpenCL context
    /////////////////////////////////////////////////////////////////
    if(UseGPU) context = clCreateContextFromType(cps, CL_DEVICE_TYPE_GPU, NULL, NULL, &status);
    else context = clCreateContextFromType(cps, CL_DEVICE_TYPE_CPU, NULL, NULL, &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Creating Context. (clCreateContextFromType)\n";
        return 1;
    }
 
    /* First, get the size of device list data */
    status = clGetContextInfo(context,
                              CL_CONTEXT_DEVICES,
                              0,
                              NULL,
                              &deviceListSize);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Getting Context Info \
            (device list size, clGetContextInfo)\n";
        return 1;
    }
 
    /////////////////////////////////////////////////////////////////
    // Detect OpenCL devices
    /////////////////////////////////////////////////////////////////
    devices = (cl_device_id *)malloc(deviceListSize);
    if(devices == 0)
    {
        std::cout<<"Error: No devices found.\n";
        return 1;
    }
 
    /* Now, get the device list data */
    status = clGetContextInfo(
                 context,
                 CL_CONTEXT_DEVICES,
                 deviceListSize,
                 devices,
                 NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Getting Context Info \
            (device list, clGetContextInfo)\n";
        return 1;
    }
 
    /////////////////////////////////////////////////////////////////
    // Create an OpenCL command queue
    /////////////////////////////////////////////////////////////////
    commandQueue = clCreateCommandQueue(
                       context,
                       devices[0],
                       0,
                       &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Creating Command Queue. (clCreateCommandQueue)\n";
        return 1;
    }
 
    /////////////////////////////////////////////////////////////////
    // Create OpenCL memory buffers
    /////////////////////////////////////////////////////////////////
 
    outputBuffer = clCreateBuffer(
                       context,
                       CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
                       sizeof(cl_uint) * width,
                       output,
                       &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: clCreateBuffer (outputBuffer)\n";
        return 1;
    }
 
 
    /////////////////////////////////////////////////////////////////
    // Load CL file, build CL program object, create CL kernel object
    /////////////////////////////////////////////////////////////////
    const char * filename  = "kernel.cl";
    std::string  sourceStr = convertToString(filename);
    const char * source    = sourceStr.c_str();
    size_t sourceSize[]    = { strlen(source) };
 
    program = clCreateProgramWithSource(
                  context,
                  1,
                  &source,
                  sourceSize,
                  &status);
    if(status != CL_SUCCESS)
    {
      std::cout<<
               "Error: Loading Binary into cl_program \
               (clCreateProgramWithBinary)\n";
      return 1;
    }
 
    /* create a cl program executable for all the devices specified */
    status = clBuildProgram(program, 1, devices, NULL, NULL, NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Building Program (clBuildProgram)\n";
        return 1;
    }
 
    /* get a kernel object handle for a kernel with the given name */
    kernel = clCreateKernel(program, "Prime", &status);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Creating Kernel from program. (clCreateKernel)\n";
        return 1;
    }
 
    return 0;
}
 
 
/*
 * \brief Run OpenCL program
 *
 *        Bind host variables to kernel arguments
 *          Run the CL kernel
 */
int
runCLKernels(void)
{
    cl_int   status;
    cl_uint maxDims;
    cl_event events[2];
     size_t maxWorkGroupSize;
    size_t maxWorkItemSizes[3];
 
    /**
    * Query device capabilities. Maximum
    * work item dimensions and the maximmum
    * work item sizes
    */
    status = clGetDeviceInfo(
        devices[0],
        CL_DEVICE_MAX_WORK_GROUP_SIZE,
        sizeof(size_t),
        (void*)&maxWorkGroupSize,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Getting Device Info. (clGetDeviceInfo)\n";
        return 1;
    }
 
    status = clGetDeviceInfo(
        devices[0],
        CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS,
        sizeof(cl_uint),
        (void*)&maxDims,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Getting Device Info. (clGetDeviceInfo)\n";
        return 1;
    }
 
    status = clGetDeviceInfo(
        devices[0],
        CL_DEVICE_MAX_WORK_ITEM_SIZES,
        sizeof(size_t)*maxDims,
        (void*)maxWorkItemSizes,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Getting Device Info. (clGetDeviceInfo)\n";
        return 1;
    }
 
    /*** Set appropriate arguments to the kernel ***/
    /* the output array to the kernel */
    status = clSetKernelArg(
                    kernel,
                    0,
                    sizeof(cl_mem),
                    (void *)&outputBuffer);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: Setting kernel argument. (output)\n";
        return 1;
    }
    status = clGetKernelWorkGroupInfo(kernel,
        devices[0],
        CL_KERNEL_LOCAL_MEM_SIZE,
        sizeof(cl_ulong),
        &usedLocalMemory,
        NULL);
    if(status != CL_SUCCESS)
    {
        std::cout<<"clGetKernelWorkGroupInfo CL_KERNEL_LOCAL_MEM_SIZE failed." << std::endl;
        return 1;
    }
 
    if(usedLocalMemory > totalLocalMemory)
    {
        std::cout << "Unsupported: Insufficient local memory on device" << std::endl;
        return 1;
    }
 
    /* Check group size against group size returned by kernel */
    status = clGetKernelWorkGroupInfo(kernel,
        devices[0],
        CL_KERNEL_WORK_GROUP_SIZE,
        sizeof(size_t),
        &kernelWorkGroupSize,
        0);
    if(status != CL_SUCCESS)
    {
        std::cout<<"clGetKernelWorkGroupInfo CL_KERNEL_COMPILE_WORK_GROUP_SIZE failed." << std::endl;
        return 1;
    }
 
    if(groupSize > kernelWorkGroupSize)
    {
        std::cout << "Out of Resources!" << std::endl;
        std::cout << "Group Size specified : " << groupSize << std::endl;
        std::cout << "Max Group Size supported on the kernel : " << kernelWorkGroupSize << std::endl;
        std::cout << "Falling back to " << kernelWorkGroupSize << std::endl;
        groupSize = kernelWorkGroupSize;
    }
    /*
     * Enqueue a kernel run call.
     */
    size_t globalThreads[] = {width};
    size_t localThreads[] = {1};
    if(localThreads[0] > maxWorkItemSizes[0] ||
       localThreads[0] > maxWorkGroupSize)
    {
        std::cout << "Unsupported: Device" "does not support requested number of work items.";
        return 1;
    }
    status = clEnqueueNDRangeKernel(
                 commandQueue,
                 kernel,
                 1,
                 NULL,
                 globalThreads,
                 localThreads,
                 0,
                 NULL,
                 &events[0]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Enqueueing kernel onto command queue. \
            (clEnqueueNDRangeKernel)\n";
        return 1;
    }
 
 
    /* wait for the kernel call to finish execution */
    status = clWaitForEvents(1, &events[0]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Waiting for kernel run to finish. \
            (clWaitForEvents)\n";
        return 1;
    }
 
    status = clReleaseEvent(events[0]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Release event object. \
            (clReleaseEvent)\n";
        return 1;
    }
 
    /* Enqueue readBuffer*/
    status = clEnqueueReadBuffer(
                commandQueue,
                outputBuffer,
                CL_TRUE,
                0,
                width * sizeof(cl_uint),
                output,
                0,
                NULL,
                &events[1]);
 
    if(status != CL_SUCCESS)
    {
        std::cout <<
            "Error: clEnqueueReadBuffer failed. \
             (clEnqueueReadBuffer)\n";
 
        return 1;
    }
 
    /* Wait for the read buffer to finish execution */
    status = clWaitForEvents(1, &events[1]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Waiting for read buffer call to finish. \
            (clWaitForEvents)\n";
        return 1;
    }
 
    status = clReleaseEvent(events[1]);
    if(status != CL_SUCCESS)
    {
        std::cout<<
            "Error: Release event object. \
            (clReleaseEvent)\n";
        return 1;
    }
 
    return 0;
}
 
 
/*
 * \brief Release OpenCL resources (Context, Memory etc.)
 */
int
cleanupCL(void)
{
    cl_int status;
 
    status = clReleaseKernel(kernel);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseKernel \n";
        return 1;
    }
    status = clReleaseProgram(program);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseProgram\n";
        return 1;
    }
    status = clReleaseMemObject(outputBuffer);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseMemObject (outputBuffer)\n";
        return 1;
    }
    status = clReleaseCommandQueue(commandQueue);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseCommandQueue\n";
        return 1;
    }
    status = clReleaseContext(context);
    if(status != CL_SUCCESS)
    {
        std::cout<<"Error: In clReleaseContext\n";
        return 1;
    }
 
    return 0;
}
 
 
/*
 * \brief Releases program's resources
 */
void
cleanupHost(void)
{
    if(output != NULL)
    {
        free(output);
        output = NULL;
    }
    if(devices != NULL)
    {
        free(devices);
        devices = NULL;
    }
}
 
 
 
int
main(int argc, char * argv[])
{
    bool GPU = true;
    for(int i = 0; i < 2; i++)
    {
    // Initialize Host application
    if(initializeHost()==1)
        return 1;
 
    // Initialize OpenCL resources
    if(initializeCL(GPU)==1)
    return 1;
/*  char C;
    do
    {
        std::cout << "Use GPU?(Y/N)" << std::endl;
        C = getch();
    }while(!((C == 'Y') || (C == 'y') || (C == 'n') || (C == 'N')));
    if(C == 'Y' || C == 'y')
    {
        if(initializeCL(true)==1)
            return 1;
    }
    else
    {
        if(initializeCL(false)==1)
            return 1;
    }*/
 
    // Run the CL program
    float Clocklast = clock();
    if(runCLKernels()==1)
        return 1;
    float Benchtime = (clock() - Clocklast) / CLOCKS_PER_SEC;
    // Print output array
    //for(int i = 0; i < width; i++) std::cout << output[i] << " ";
    if(GPU) std::cout << "With GPU: "; else std::cout << "With CPU: ";
    std::cout << Benchtime << " Seconds" << std::endl;
        // Releases OpenCL resources
    if(cleanupCL()==1)
        return 1;
 
    // Release host resources
    cleanupHost();
    GPU = false;
    }
    return 0;
}
 
 

Main.hpp:

#include <CL/cl.h>
#include <string.h>
#include <cstdlib>
#include <iostream>
#include <time.h>
#include <fstream>
#include <conio.h>
/*** GLOBALS ***/
 
cl_uint *output;
cl_ulong totalLocalMemory;
cl_ulong usedLocalMemory;
size_t kernelWorkGroupSize;
size_t groupSize;
cl_uint width;
 
/* The memory buffer that is used as input/output for OpenCL kernel */
cl_mem     outputBuffer;
 
cl_context          context;
cl_device_id        *devices;
cl_command_queue    commandQueue;
 
cl_program program;
 
/* This program uses only one kernel and this serves as a handle to it */
cl_kernel  kernel;
 
 
/*** FUNCTION DECLARATIONS ***/
/*
 * OpenCL related initialisations are done here.
 * Context, Device list, Command Queue are set up.
 * Calls are made to set up OpenCL memory buffers that this program uses
 * and to load the programs into memory and get kernel handles.
 */
int initializeCL(bool UseGPU);
 
/*
 *
 */
std::string convertToString(const char * filename);
 
/*
 * This is called once the OpenCL context, memory etc. are set up,
 * the program is loaded into memory and the kernel handles are ready.
 *
 * It sets the values for kernels' arguments and enqueues calls to the kernels
 * on to the command queue and waits till the calls have finished execution.
 *
 * It also gets kernel start and end time if profiling is enabled.
 */
int runCLKernels(void);
 
/* Releases OpenCL resources (Context, Memory etc.) */
int cleanupCL(void);
 
/* Releases program's resources */
void cleanupHost(void);
/*
 * Prints no more than 256 elements of the given array.
 * Prints full array if length is less than 256.
 *
 * Prints Array name followed by elements.
 */
void print1DArray(
         const std::string arrayName,
         const unsigned long * arrayData,
         const unsigned int length);
 

Kernel.cl

__kernel
void Prime(
    __global unsigned int * output)
{
	uint tid = get_global_id(0);
	output[tid] = 2 * tid;
}
 

El kernel es muy simple, iba a calcular primos, por eso se llama "prime" pero bueno, todavía no me puse a hacerlo.

Un abrazo
APOKLIPTICO

Hola gente, como va todo?
Estoy jugando un poco con la tecnología opencl y atistream, y entonces, me puse a tratar de adaptar un sample de Nbody, muy interesante que viene con el SDK a mi IDE code::blocks + Mingw. Pero me encontré con algunos problemas, cuando pude resolver todos los problemas del linker, me encontré con estos pedazos de código:

#if defined (_WIN32)
    pos = (cl_float*)malloc_align(numBodies * sizeof(cl_float4),16);
#else
    pos = (cl_float*)memalign(16, numBodies * sizeof(cl_float4));
#endif

y

#if defined (_WIN32)
       free_align (pos);
#else
        free(pos);
#endif

No pude encontrar los includes que funcionan con codeblocks + mingw, entonces pensé si era posible usar los operadores "new" y "delete" para allocar la memoria. Pero despues de probar varias formas, decidí pedir ayuda.
Alguien sabe cual es el include que funciona con esto, o como adaptarlo para que funcione con "new" y "delete"??
Muchas gracias!

Hola gente, como va todo? Bueno hoy traigo dos preguntas:
1) Hay algún buen programa que tenga la opción de "scan for artifacts" como hacía el ATI TOOL, pero que ande? (aclaro: el ati tool no me anda). Es que quiero overclockear mi ATI HD 4850 pero no quiero tener que ponerme a jugar cada vez que hago un cambio para ver si salen artifacts.

2) Hay alguna manera de overclockear mi micro Sempron 2500+ con un chipset nforce 410/430mcp. Aclaro:
- No me anda Ntune/Nvidia system settings. Dejó de funcionar hace un tiempo y no se como puedo llegar a hacerlo funcionar (ni siquiera los de nvidia saben aparentemente). El problema en cuestión es que el slider para modificar el bus, me aparece con rangos ridículos (de 0 Mhz a 20 Mhz), al poner "apply" me tira un error "FSB Bus modification: error. Se han restablecido los valores". Tampoco funciona ejecutando los archivitos .nsu.
- No me anda el clockgen, cuando hago click en apply, me hace toda la pantomima como si los hubiese aplicado, pero no lo hace.
- Ni el SetFSB, aparentemente no tiene soporte para nforce 410.
- Tampoco el CPUCOOL/CPUFSB.
- Lo único que puedo modificar por bios es el Vdimm y los timings (el primero no me sirve demasiado y el segundo lo puedo modificar con memset).

Alguien sabe algo?
Gracias!
Un abrazo
APOKLIPTICO