Mensajes

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

Insecure Cryptographic Storage is a common vulnerability that occurs when sensitive data is not stored securely. Protecting sensitive data by encrypting it should be a key step in a Secure Software Development Lifecycle

Saludos!

Creo que asi deberia de quedar

Código (c) [Seleccionar] Expandir

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

Código (c) [Seleccionar] Expandir

#include<stdbool.h>

bool error = false;

if(opcion > ALGO ){
error = true;
}

[Libcrypto]

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

Libgcrypt is a general purpose cryptographic library based on the code from GnuPG. It provides functions for all cryptograhic building blocks: symmetric ciphers (AES, DES, Blowfish, CAST5, Twofish, SEED, Camellia, Arcfour), hash algorithms (MD4, MD5, RIPE-MD160, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, TIGER-192, Whirlpool), MACs (HMAC for all hash algorithms), public key algorithms (RSA, Elgamal, DSA, ECDSA), large integer functions, random numbers and a lot of supporting functions.

Libgcrypt works on most POSIX systems and many pre-POSIX systems. It can also be built using a cross-compiler system for Microsoft Windows.

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

Código (c) [Seleccionar] Expandir

   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:

Código (c) [Seleccionar] Expandir


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:

Código (c) [Seleccionar] Expandir

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

Código (cpp) [Seleccionar] Expandir

#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!

Tengo Cygwin y funciona bien, el detalle que como voy a distribuir la aplicación, quiero que sea lo mas estándar posible (Acorde a cada sistema) y que dependa de la menor cantidad de recursos externos.

Saludos!