Primero se posicionan como los mejores y luego sueltan la *****....

Yo no uso ninguno de los que mencionan, solo mantengo mi archivo / etc / hosts al dia 

Saludos

En mi caso solo fue por que la librería que usaba no estaba totalmente portada para windows.

En general es preferible (Criptograficamente) establecer todos los parámetros para el cifrado aunque se trate de cifrado simétrico (AES) existen muchas variedades y cosas que definir, como el IV (Vector de Inizialisacion) tambien el KEY (Tu clave) + el tipo de cifrado (AES128, AES256) y modo de cifrado (ECB, CFB, CBC,CCM,GCM).

No todos son compatibles entre si, y algunas implementaciones no son tan seguras como otras.

Yo prefiero escribir 20 lineas a una sola. O mejor aun crear mi propia función acorde a mis necesidades y llamarla con una sola linea (Que es lo que realizo actualmente), no es tan dificil, tal vez, solo te falta leer un poco mas de criptografia y entender mas o menos los conceptos y con eso no sera tan dificil entender esas 20 lineas.

Ademas mientras es posible personalizar tanto el codigo como deees para que se adapte a cualquier tipo de proyecto.

He visto implementaciones criptograficas INSEGURAS de una sola linea como la que mencionas que no son tan seguras muchas de ellas incluso "Incluyen" el Material para descifrar dentro del mismo mensaje "supuestamente" cifrado.

Ver mas:

https://www.owasp.org/index.php/Top_10_2010-A7-Insecure_Cryptographic_Storage
http://www.veracode.com/blog/2012/06/insecure-cryptographic-storage-explained

Saludos!

Creo que asi deberia de quedar

char * subcadena (char * p, unsigned int i, unsigned int n)	{
	int j=0;
	char *pc;
	pc=malloc(n-i+1);
	while(*(p+i+j)!='\0' && (i+j)<=n)	{
		*(pc+j)=*(p+i+j);
		j++;
	}
	*(pc+i+j)='\0';
	return pc;
}

Saludos!

Pon el codigo que llevas para guiarte mejor

#include<stdbool.h>
 
bool error = false;
 
if(opcion > ALGO ){
error = true;
}

En construcción

---

Libcrypto
Documentación: No esta muy ordenada
https://wiki.openssl.org/index.php/Libcrypto_API


Libgcrypt
Documentación: Excelente
Algoritmos: La mayoria de los Simetricos y siguen desarrollando los Asimetricos

https://www.gnu.org/software/libgcrypt/
https://gnupg.org/download/index.html#libgcrypt

---

Abro el tema por que me he encontrado con el problema de usar una librería de cifrado en Windows, el problema que el proyecto que estoy haciendo en C en FreeBSD lo hice con libgcrypt pero esta NO se puede portar tan fácilmente a windows Y cada que alguien preguntaba por alguna librería asi yo siempre recomendaba libgcrypt (Mas que nada la recomendaba por completa suite de algoritmos y excelente documentación).

Realmente no conozco muchas librerias de este tipo ya que siempre trabaje con libgcrypt y me parecia muy completa,
¿podrian comentar algunas mas que usen o conozcan y que tambien funcionen con windows y no tengan tantas dependencias?

Saludos!

Pues en teoria estoy creando un thread y no un proceso hay una funcion en windows que hace precisamente eso (CreateProcess) el tema lo trate aqui:

https://foro.elhacker.net/programacion_cc/createthread_o_createprocess-t458039.0.html

Y si al final decidi usar los threads al estilo de windows y funciona bastante bien. ya que lo termine probare el metodo que indicas.

Saludos!

Pues basta con poner la tarjeta de red en modo monitor usando airmon de la suite de aircrack para poder vel el trafico de otros dispositivos, ademas de capturarlos ya sera con aerodump o con wireshark ya una vez capturado todo el trafico es posible (Dependiendo del tipo de red y protocolos de cifrado) ver el raw de los datos enviados a la impresora

La opcion adecuada es monitorear el trafico Wireless y guardar todo lo que se le envie a Esa IP, ya la con la informacion en mano seria posible ver los documentos impresos, solo hay que decifrarlos (supongo que va mediante alguna capa de seguridad no creo que sea tan facil como sniffear otros datos en texto plano)

Saludos!

Que tal Pongo aqui la solucion que encontre al problema de no tener fork en Windows, la solucion es CreateThread de la winapi

    if(listen(ListenSocket, BACKLOG) == SOCKET_ERROR) {
		printf("listen failed with error: %ld\n", WSAGetLastError());
		closesocket(ListenSocket);
		WSACleanup();
        return 1;
    }
	while(entrar)	{//Entrar es true solo se cambia por otro segmento del codigo en caso de que queramos finalizar con el hilo principal
		b = sizeof(struct sockaddr_in);
		client = accept(ListenSocket,(SOCKADDR *) service,&b);
		if(client == INVALID_SOCKET)	{
			exit(1);
		}
		toThread = malloc(sizeof(SOCKET));
		memcpy(toThread,&client,sizeof(SOCKET));// Copiamos la variable socket principal para pasarla al thread
		hThread = CreateThread( 
            NULL,                   // default security attributes
            0,                      // use default stack size  
            client_funtion,       // thread function name
            toThread,          // argument to thread function 
            0,                      // use default creation flags 
            &dwThreadId);   // returns the thread identifier 
		printf("Thread ID %u\n",dwThreadId);
		if(hThread == NULL) 	{
           free(toThread);
		   exit(0)
        }
	}
    closesocket(ListenSocket);

hay que tener en cuenta que necesitasmos una funcion para el Thread:

DWORD WINAPI client_funtion( LPVOID lpParam )	{
//Variables
// aqui recivir datos y procesarlos, se puede llamar a otras funciones que sean Thread safe
}
 

Si no queremos que el hilo principal se "preocupe" por cerrar estas conexiones y terminar con el hilo podemos poner lo siguiente:

DWORD WINAPI client_funtion( LPVOID lpParam )	{
	HANDLE thread_id;
	thread_id = GetCurrentThread();
	//Otras variables
	//codigo aque para procesar al cliente correctamente
 
	free(lpParam); //Si lpParam es un parametro que tenemos que liberar entonces Free
 
	CloseHandle(thread_id);	//Terminamos con nuestro propio Thread
}
 

Me base en el ejemplo puesto aqui:

http://foro.elhacker.net/programacion_cc/createthread_o_createprocess-t458039.0.html

Saludos

Si ya vi que lo que necesito es un thread nuevo lo cual seria lo mas parecido a fork aun que con ligeros cambios

Estoy validando este ejemplo de Windows:

https://msdn.microsoft.com/en-us/library/windows/desktop/ms682516(v=vs.85).aspx

#include <windows.h>
#include <tchar.h>
#include <strsafe.h>
 
#define MAX_THREADS 3
#define BUF_SIZE 255
 
DWORD WINAPI MyThreadFunction( LPVOID lpParam );
void ErrorHandler(LPTSTR lpszFunction);
 
// Sample custom data structure for threads to use.
// This is passed by void pointer so it can be any data type
// that can be passed using a single void pointer (LPVOID).
typedef struct MyData {
    int val1;
    int val2;
} MYDATA, *PMYDATA;
 
 
int _tmain()
{
    PMYDATA pDataArray[MAX_THREADS];
    DWORD   dwThreadIdArray[MAX_THREADS];
    HANDLE  hThreadArray[MAX_THREADS]; 
 
    // Create MAX_THREADS worker threads.
 
    for( int i=0; i<MAX_THREADS; i++ )
    {
        // Allocate memory for thread data.
 
        pDataArray[i] = (PMYDATA) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                sizeof(MYDATA));
 
        if( pDataArray[i] == NULL )
        {
           // If the array allocation fails, the system is out of memory
           // so there is no point in trying to print an error message.
           // Just terminate execution.
            ExitProcess(2);
        }
 
        // Generate unique data for each thread to work with.
 
        pDataArray[i]->val1 = i;
        pDataArray[i]->val2 = i+100;
 
        // Create the thread to begin execution on its own.
 
        hThreadArray[i] = CreateThread( 
            NULL,                   // default security attributes
            0,                      // use default stack size  
            MyThreadFunction,       // thread function name
            pDataArray[i],          // argument to thread function 
            0,                      // use default creation flags 
            &dwThreadIdArray[i]);   // returns the thread identifier 
 
 
        // Check the return value for success.
        // If CreateThread fails, terminate execution. 
        // This will automatically clean up threads and memory. 
 
        if (hThreadArray[i] == NULL) 
        {
           ErrorHandler(TEXT("CreateThread"));
           ExitProcess(3);
        }
    } // End of main thread creation loop.
 
    // Wait until all threads have terminated.
 
    WaitForMultipleObjects(MAX_THREADS, hThreadArray, TRUE, INFINITE);
 
    // Close all thread handles and free memory allocations.
 
    for(int i=0; i<MAX_THREADS; i++)
    {
        CloseHandle(hThreadArray[i]);
        if(pDataArray[i] != NULL)
        {
            HeapFree(GetProcessHeap(), 0, pDataArray[i]);
            pDataArray[i] = NULL;    // Ensure address is not reused.
        }
    }
 
    return 0;
}
 
 
DWORD WINAPI MyThreadFunction( LPVOID lpParam ) 
{ 
    HANDLE hStdout;
    PMYDATA pDataArray;
 
    TCHAR msgBuf[BUF_SIZE];
    size_t cchStringSize;
    DWORD dwChars;
 
    // Make sure there is a console to receive output results. 
 
    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    if( hStdout == INVALID_HANDLE_VALUE )
        return 1;
 
    // Cast the parameter to the correct data type.
    // The pointer is known to be valid because 
    // it was checked for NULL before the thread was created.
 
    pDataArray = (PMYDATA)lpParam;
 
    // Print the parameter values using thread-safe functions.
 
    StringCchPrintf(msgBuf, BUF_SIZE, TEXT("Parameters = %d, %d\n"), 
        pDataArray->val1, pDataArray->val2); 
    StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);
    WriteConsole(hStdout, msgBuf, (DWORD)cchStringSize, &dwChars, NULL);
 
    return 0; 
} 
 
 
 
void ErrorHandler(LPTSTR lpszFunction) 
{ 
    // Retrieve the system error message for the last-error code.
 
    LPVOID lpMsgBuf;
    LPVOID lpDisplayBuf;
    DWORD dw = GetLastError(); 
 
    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );
 
    // Display the error message.
 
    lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT, 
        (lstrlen((LPCTSTR) lpMsgBuf) + lstrlen((LPCTSTR) lpszFunction) + 40) * sizeof(TCHAR)); 
    StringCchPrintf((LPTSTR)lpDisplayBuf, 
        LocalSize(lpDisplayBuf) / sizeof(TCHAR),
        TEXT("%s failed with error %d: %s"), 
        lpszFunction, dw, lpMsgBuf); 
    MessageBox(NULL, (LPCTSTR) lpDisplayBuf, TEXT("Error"), MB_OK); 
 
    // Free error-handling buffer allocations.
 
    LocalFree(lpMsgBuf);
    LocalFree(lpDisplayBuf);
}
 

Aunque parece complicado veo que no esta dificil de implementar y ajustar a mi proyecto, lo que si tengo que hacer es una función nueva que seria el equivalente a lo que tengo dentro del switch incluso estoy dejando las 2 versiones con la misma cantidad de lineas y solo dejo huecos donde existe diferencia entre una version y la otra

Saludos!