/* M.encrypt(aes_ctx, message_string) returns ciphered_string or nil+error_num. */ static int api_encrypt( lua_State *L) { OAES_CTX *ctx = checkctx( L, 1); size_t srclen, dstlen; const uint8_t *src = (const uint8_t *) luaL_checklstring( L, 2, & srclen); uint8_t *dst; oaes_encrypt( ctx, src, srclen, NULL, & dstlen); // retrieve dstlen dst = malloc( dstlen); if( ! dst) { lua_pushnil( L); lua_pushinteger( L, OAES_RET_MEM); return 2; } int r = oaes_encrypt( ctx, src, srclen, dst, & dstlen); if( r) { free( dst); lua_pushnil( L); lua_pushinteger( L, r); return 2; } lua_pushlstring( L, (const char *) dst, dstlen); free( dst); return 1; }
// caller must free b->out if it's not NULL static OAES_RET _do_aes_encrypt(do_block *b) { OAES_CTX * ctx = NULL; OAES_RET _rc = OAES_RET_SUCCESS; if( NULL == b ) return OAES_RET_ARG1; ctx = oaes_alloc(); if( NULL == ctx ) { fprintf(stderr, "Error: Failed to initialize OAES.\n"); return OAES_RET_MEM; } if( _is_ecb ) if( OAES_RET_SUCCESS != oaes_set_option( ctx, OAES_OPTION_ECB, NULL ) ) fprintf(stderr, "Error: Failed to set OAES options.\n"); oaes_key_import_data( ctx, _key_data, _key_data_len ); b->out = NULL; b->out_len = 0; _rc = oaes_encrypt( ctx, b->in, b->in_len, b->out, &(b->out_len) ); if( OAES_RET_SUCCESS != _rc ) { fprintf(stderr, "Error: Failed to encrypt.\n"); oaes_free(&ctx); return _rc; } b->out = (uint8_t *) calloc(b->out_len, sizeof(uint8_t)); if( NULL == b->out ) { fprintf(stderr, "Error: Failed to allocate memory.\n"); oaes_free(&ctx); return OAES_RET_MEM; } _rc = oaes_encrypt( ctx, b->in, b->in_len, b->out, &(b->out_len) ); if( OAES_RET_SUCCESS != oaes_free(&ctx) ) fprintf(stderr, "Error: Failed to uninitialize OAES.\n"); return _rc; }
int Encrypt( const std::vector<unsigned char>& plaintext, std::vector<unsigned char>& ciphertext ) { if( plaintext.size() == 0 ) return -1; if( m_ctx == NULL ) { LOG_PRINT_ERROR( "m_ctx == NULL." ); return -1; } size_t encryption_buffer_size = 0; OAES_RET ret = oaes_encrypt( m_ctx, (const uint8_t *)&plaintext[0], plaintext.size(), NULL, &encryption_buffer_size ); if( ret != OAES_RET_SUCCESS ) { LOG_PRINTF_ERROR(( "Failed to retrieve required buffer size for encryption: %d", (int)ret )); return -1; } if( encryption_buffer_size == 0 ) { LOG_PRINT_ERROR( "The required encryption buffer size == 0." ); return -1; } ciphertext.resize( 0 ); ciphertext.resize( encryption_buffer_size ); ret = oaes_encrypt( m_ctx, (const uint8_t *)&plaintext[0], plaintext.size(), &ciphertext[0], &encryption_buffer_size ); if( ret != OAES_RET_SUCCESS ) { LOG_PRINTF_ERROR(( "Encryption failed: %d", (int)ret )); return -1; } return 0; }
/* Input thread proc */ static void inputSendThreadProc(void* context) { SOCK_RET err; PPACKET_HOLDER holder; char encryptedBuffer[MAX_INPUT_PACKET_SIZE]; size_t encryptedSize; while (!PltIsThreadInterrupted(&inputSendThread)) { int encryptedLengthPrefix; err = LbqWaitForQueueElement(&packetQueue, (void**) &holder); if (err != LBQ_SUCCESS) { return; } // If it's a multi-controller packet we can do batching if (holder->packet.multiController.header.packetType == htonl(PACKET_TYPE_MULTI_CONTROLLER)) { PPACKET_HOLDER controllerBatchHolder; PNV_MULTI_CONTROLLER_PACKET origPkt; int dirs[6]; memset(dirs, 0, sizeof(dirs)); origPkt = &holder->packet.multiController; for (;;) { PNV_MULTI_CONTROLLER_PACKET newPkt; // Peek at the next packet if (LbqPeekQueueElement(&packetQueue, (void**)&controllerBatchHolder) != LBQ_SUCCESS) { break; } // If it's not a controller packet, we're done if (controllerBatchHolder->packet.multiController.header.packetType != htonl(PACKET_TYPE_MULTI_CONTROLLER)) { break; } // Check if it's able to be batched newPkt = &controllerBatchHolder->packet.multiController; if (newPkt->buttonFlags != origPkt->buttonFlags || newPkt->controllerNumber != origPkt->controllerNumber || !checkDirs(origPkt->leftTrigger, newPkt->leftTrigger, &dirs[0]) || !checkDirs(origPkt->rightTrigger, newPkt->rightTrigger, &dirs[1]) || !checkDirs(origPkt->leftStickX, newPkt->leftStickX, &dirs[2]) || !checkDirs(origPkt->leftStickY, newPkt->leftStickY, &dirs[3]) || !checkDirs(origPkt->rightStickX, newPkt->rightStickX, &dirs[4]) || !checkDirs(origPkt->rightStickY, newPkt->rightStickY, &dirs[5])) { // Batching not allowed break; } // Remove the batchable controller packet if (LbqPollQueueElement(&packetQueue, (void**)&controllerBatchHolder) != LBQ_SUCCESS) { break; } // Update the original packet origPkt->leftTrigger = newPkt->leftTrigger; origPkt->rightTrigger = newPkt->rightTrigger; origPkt->leftStickX = newPkt->leftStickX; origPkt->leftStickY = newPkt->leftStickY; origPkt->rightStickX = newPkt->rightStickX; origPkt->rightStickY = newPkt->rightStickY; // Free the batched packet holder free(controllerBatchHolder); } } // If it's a mouse move packet, we can also do batching else if (holder->packet.mouseMove.header.packetType == htonl(PACKET_TYPE_MOUSE_MOVE)) { PPACKET_HOLDER mouseBatchHolder; int totalDeltaX = (short)htons(holder->packet.mouseMove.deltaX); int totalDeltaY = (short)htons(holder->packet.mouseMove.deltaY); for (;;) { int partialDeltaX; int partialDeltaY; // Peek at the next packet if (LbqPeekQueueElement(&packetQueue, (void**)&mouseBatchHolder) != LBQ_SUCCESS) { break; } // If it's not a mouse move packet, we're done if (mouseBatchHolder->packet.mouseMove.header.packetType != htonl(PACKET_TYPE_MOUSE_MOVE)) { break; } partialDeltaX = (short)htons(mouseBatchHolder->packet.mouseMove.deltaX); partialDeltaY = (short)htons(mouseBatchHolder->packet.mouseMove.deltaY); // Check for overflow if (partialDeltaX + totalDeltaX > INT16_MAX || partialDeltaX + totalDeltaX < INT16_MIN || partialDeltaY + totalDeltaY > INT16_MAX || partialDeltaY + totalDeltaY < INT16_MIN) { // Total delta would overflow our 16-bit short break; } // Remove the batchable mouse move packet if (LbqPollQueueElement(&packetQueue, (void**)&mouseBatchHolder) != LBQ_SUCCESS) { break; } totalDeltaX += partialDeltaX; totalDeltaY += partialDeltaY; // Free the batched packet holder free(mouseBatchHolder); } // Update the original packet holder->packet.mouseMove.deltaX = htons((short)totalDeltaX); holder->packet.mouseMove.deltaY = htons((short)totalDeltaY); } encryptedSize = sizeof(encryptedBuffer); err = oaes_encrypt(oaesContext, (const unsigned char*) &holder->packet, holder->packetLength, (unsigned char*) encryptedBuffer, &encryptedSize); free(holder); if (err != OAES_RET_SUCCESS) { Limelog("Input: Encryption failed: %d\n", (int)err); ListenerCallbacks.connectionTerminated(err); return; } // The first 32-bytes of the output are internal OAES stuff that we want to ignore encryptedSize -= OAES_DATA_OFFSET; // Overwrite the last 4 bytes before the encrypted data with the length so // we can send the message all at once. GFE can choke if it gets the header // before the rest of the message. encryptedLengthPrefix = htonl((unsigned long) encryptedSize); memcpy(&encryptedBuffer[OAES_DATA_OFFSET - sizeof(encryptedLengthPrefix)], &encryptedLengthPrefix, sizeof(encryptedLengthPrefix)); // Send the encrypted payload err = send(inputSock, (const char*) &encryptedBuffer[OAES_DATA_OFFSET - sizeof(encryptedLengthPrefix)], (int)(encryptedSize + sizeof(encryptedLengthPrefix)), 0); if (err <= 0) { Limelog("Input: send() failed: %d\n", (int)LastSocketError()); ListenerCallbacks.connectionTerminated(LastSocketError()); return; } } }
int main(int argc, char** argv) { size_t _i; OAES_CTX * ctx = NULL; uint8_t *_encbuf, *_decbuf, *_key_data = NULL, *_bin_data = NULL; size_t _encbuf_len, _decbuf_len, _buf_len; size_t _key_data_len = 0, _bin_data_len = 0; char *_buf; short _is_ecb = 0, _is_bin = 0; char * _text = NULL, * _key_text = NULL; int _key_len = 128; uint8_t _iv[OAES_BLOCK_SIZE] = ""; uint8_t _pad = 0; if( argc < 2 ) { usage( argv[0] ); return EXIT_FAILURE; } for( _i = 1; _i < argc; _i++ ) { int _found = 0; if( 0 == strcmp( argv[_i], "-nostep" ) ) { _found = 1; _is_step = 0; } if( 0 == strcmp( argv[_i], "-ecb" ) ) { _found = 1; _is_ecb = 1; } if( 0 == strcmp( argv[_i], "-bin" ) ) { _found = 1; _is_bin = 1; } if( 0 == strcmp( argv[_i], "-key" ) ) { _found = 1; _i++; // len if( _i >= argc ) { printf("Error: No value specified for '-%s'.\n", "key"); usage( argv[0] ); return EXIT_FAILURE; } _key_len = atoi( argv[_i] ); switch( _key_len ) { case 128: case 192: case 256: break; default: _key_text = argv[_i]; if( to_binary( NULL, &_key_data_len, _key_text ) ) { printf( "Error: Invalid value [%s] specified for '-%s'.\n", argv[_i], "key" ); return EXIT_FAILURE; } switch( _key_data_len ) { case 16: case 24: case 32: break; default: printf("Error: key_data [%s] specified for '-%s' has an invalid " "size.\n", argv[_i], "key"); usage( argv[0] ); return EXIT_FAILURE; } } } if( 0 == _found ) { if( _text ) { printf("Error: Invalid option '%s'.\n", argv[_i]); usage( argv[0] ); return EXIT_FAILURE; } else { _text = argv[_i]; if( _is_bin && to_binary( NULL, &_bin_data_len, _text ) ) { printf( "Error: Invalid value [%s] specified for '-%s'.\n", argv[_i], "bin" ); return EXIT_FAILURE; } } } } if( NULL == _text ) { usage( argv[0] ); return EXIT_FAILURE; } if( _is_step ) printf( "\nEnabling step mode, press Return to step.\n\n" ); if( _is_bin ) { _bin_data = (uint8_t *) calloc(_bin_data_len, sizeof(uint8_t)); if( NULL == _bin_data ) { printf( "Error: Failed to allocate memory.\n" ); return EXIT_FAILURE; } if( to_binary( _bin_data, &_bin_data_len, _text ) ) { printf( "Error: Could not load data [%s].\n", _text); free( _bin_data ); return EXIT_FAILURE; } } else { oaes_sprintf( NULL, &_buf_len, (const uint8_t *)_text, strlen(_text)); _buf = (char *) calloc(_buf_len, sizeof(char)); printf( "\n***** plaintext *****\n" ); if( _buf ) { oaes_sprintf( _buf, &_buf_len, (const uint8_t *)_text, strlen( _text ) ); printf( "%s", _buf ); } printf( "\n**********************\n" ); free( _buf ); } ctx = oaes_alloc(); if( NULL == ctx ) { printf("Error: Failed to initialize OAES.\n"); if( _bin_data ) free( _bin_data ); return EXIT_FAILURE; } if( OAES_RET_SUCCESS != oaes_set_option( ctx, OAES_OPTION_STEP_ON, step_cb ) ) printf("Error: Failed to set OAES options.\n"); if( _is_ecb ) if( OAES_RET_SUCCESS != oaes_set_option( ctx, OAES_OPTION_ECB, NULL ) ) printf("Error: Failed to set OAES options.\n"); if( _key_text ) { _key_data = (uint8_t *) calloc(_key_data_len, sizeof(uint8_t)); if( NULL == _key_data ) { printf( "Error: Failed to allocate memory.\n" ); if( _bin_data ) free( _bin_data ); return EXIT_FAILURE; } if( to_binary( _key_data, &_key_data_len, _key_text ) ) { printf( "Error: Could not load key [%s].\n", _key_text); free( _key_data ); return EXIT_FAILURE; } oaes_key_import_data( ctx, _key_data, _key_data_len ); } else switch( _key_len ) { case 128: if( OAES_RET_SUCCESS != oaes_key_gen_128(ctx) ) printf("Error: Failed to generate OAES %d bit key.\n", _key_len); break; case 192: if( OAES_RET_SUCCESS != oaes_key_gen_192(ctx) ) printf("Error: Failed to generate OAES %d bit key.\n", _key_len); break; case 256: if( OAES_RET_SUCCESS != oaes_key_gen_256(ctx) ) printf("Error: Failed to generate OAES %d bit key.\n", _key_len); break; default: break; } if( _bin_data ) { if( OAES_RET_SUCCESS != oaes_encrypt( ctx, _bin_data, _bin_data_len, NULL, &_encbuf_len, NULL, NULL ) ) printf("Error: Failed to retrieve required buffer size for encryption.\n"); _encbuf = (uint8_t *) calloc(_encbuf_len, sizeof(uint8_t)); if( NULL == _encbuf ) { printf( "Error: Failed to allocate memory.\n" ); if( _key_data ) free( _key_data ); free( _bin_data ); return EXIT_FAILURE; } printf( "\n" ); if( OAES_RET_SUCCESS != oaes_encrypt( ctx, _bin_data, _bin_data_len, _encbuf, &_encbuf_len, _iv, &_pad ) ) printf("Error: Encryption failed.\n"); printf( "\n**********************\n\n" ); } else { if( OAES_RET_SUCCESS != oaes_encrypt( ctx, (const uint8_t *)_text, strlen( _text ), NULL, &_encbuf_len, NULL, NULL ) ) printf("Error: Failed to retrieve required buffer size for encryption.\n"); _encbuf = (uint8_t *) calloc(_encbuf_len, sizeof(uint8_t)); if( NULL == _encbuf ) { printf( "Error: Failed to allocate memory.\n" ); if( _key_data ) free( _key_data ); return EXIT_FAILURE; } printf( "\n" ); if( OAES_RET_SUCCESS != oaes_encrypt( ctx, (const uint8_t *)_text, strlen( _text ), _encbuf, &_encbuf_len, _iv, &_pad )) printf("Error: Encryption failed.\n"); printf( "\n**********************\n\n" ); } if( OAES_RET_SUCCESS != oaes_decrypt( ctx, _encbuf, _encbuf_len, NULL, &_decbuf_len, NULL, NULL ) ) printf("Error: Failed to retrieve required buffer size for encryption.\n"); _decbuf = (uint8_t *) calloc(_decbuf_len, sizeof(uint8_t)); if( NULL == _decbuf ) { printf( "Error: Failed to allocate memory.\n" ); if( _key_data ) free( _key_data ); if( _bin_data ) free( _bin_data ); free( _encbuf ); return EXIT_FAILURE; } if( OAES_RET_SUCCESS != oaes_decrypt( ctx, _encbuf, _encbuf_len, _decbuf, &_decbuf_len, _iv, _pad ) ) printf("Error: Decryption failed.\n"); if( OAES_RET_SUCCESS != oaes_free( &ctx ) ) printf("Error: Failed to uninitialize OAES.\n"); oaes_sprintf( NULL, &_buf_len, _encbuf, _encbuf_len ); _buf = (char *) calloc(_buf_len, sizeof(char)); printf( "\n***** cyphertext *****\n" ); if( _buf ) { oaes_sprintf( _buf, &_buf_len, _encbuf, _encbuf_len ); printf( "%s", _buf ); } printf( "\n**********************\n" ); free( _buf ); oaes_sprintf( NULL, &_buf_len, _decbuf, _decbuf_len ); _buf = (char *) calloc(_buf_len, sizeof(char)); printf( "\n***** plaintext *****\n" ); if( _buf ) { oaes_sprintf( _buf, &_buf_len, _decbuf, _decbuf_len ); printf( "%s", _buf ); } printf( "\n**********************\n\n" ); free( _buf ); free( _encbuf ); free( _decbuf ); if( _key_data ) free( _key_data ); if( _bin_data ) free( _bin_data ); return (EXIT_SUCCESS); }
int main(int argc, char** argv) { size_t _i; OAES_CTX * ctx = NULL; uint8_t *_encbuf, *_decbuf; size_t _encbuf_len, _decbuf_len, _buf_len; char *_buf; short _is_ecb = 0; char * _text = NULL; int _key_len = 128; if( argc < 2 ) { usage( argv[0] ); return EXIT_FAILURE; } for( _i = 1; _i < argc; _i++ ) { int _found = 0; if( 0 == strcmp( argv[_i], "-ecb" ) ) { _found = 1; _is_ecb = 1; } if( 0 == strcmp( argv[_i], "-key" ) ) { _found = 1; _i++; // len if( _i >= argc ) { printf("Error: No value specified for '-%s'.\n", "key"); usage( argv[0] ); return EXIT_FAILURE; } _key_len = atoi( argv[_i] ); switch( _key_len ) { case 128: case 192: case 256: break; default: printf("Error: Invalid value [%d] specified for '-%s'.\n", _key_len, "key"); usage( argv[0] ); return EXIT_FAILURE; } } if( 0 == _found ) { if( _text ) { printf("Error: Invalid option '%s'.\n", argv[_i]); usage( argv[0] ); return EXIT_FAILURE; } else { _text = (char *) calloc(strlen( argv[_i] ) + 1, sizeof(char)); if( NULL == _text ) { printf("Error: Failed to allocate memory.\n", argv[_i]); return EXIT_FAILURE; } strcpy( _text, argv[_i] ); } } } if( NULL == _text ) { usage( argv[0] ); return EXIT_FAILURE; } oaes_sprintf( NULL, &_buf_len, (const uint8_t *)_text, strlen( _text ) ); _buf = (char *) calloc(_buf_len, sizeof(char)); printf( "\n***** plaintext *****\n" ); if( _buf ) { oaes_sprintf( _buf, &_buf_len, (const uint8_t *)_text, strlen( _text ) ); printf( "%s", _buf ); } printf( "\n**********************\n" ); free( _buf ); ctx = oaes_alloc(); if( NULL == ctx ) { printf("Error: Failed to initialize OAES.\n"); free( _text ); return EXIT_FAILURE; } if( _is_ecb ) if( OAES_RET_SUCCESS != oaes_set_option( ctx, OAES_OPTION_ECB, NULL ) ) printf("Error: Failed to set OAES options.\n"); switch( _key_len ) { case 128: if( OAES_RET_SUCCESS != oaes_key_gen_128(ctx) ) printf("Error: Failed to generate OAES %d bit key.\n", _key_len); break; case 192: if( OAES_RET_SUCCESS != oaes_key_gen_192(ctx) ) printf("Error: Failed to generate OAES %d bit key.\n", _key_len); break; case 256: if( OAES_RET_SUCCESS != oaes_key_gen_256(ctx) ) printf("Error: Failed to generate OAES %d bit key.\n", _key_len); break; default: break; } if( OAES_RET_SUCCESS != oaes_encrypt( ctx, (const uint8_t *)_text, strlen( _text ), NULL, &_encbuf_len ) ) printf("Error: Failed to retrieve required buffer size for encryption.\n"); _encbuf = (uint8_t *) calloc( _encbuf_len, sizeof(uint8_t) ); if( NULL == _encbuf ) { printf( "Error: Failed to allocate memory.\n" ); free( _text ); return EXIT_FAILURE; } if( OAES_RET_SUCCESS != oaes_encrypt( ctx, (const uint8_t *)_text, strlen( _text ), _encbuf, &_encbuf_len ) ) printf("Error: Encryption failed.\n"); if( OAES_RET_SUCCESS != oaes_decrypt( ctx, _encbuf, _encbuf_len, NULL, &_decbuf_len ) ) printf("Error: Failed to retrieve required buffer size for encryption.\n"); _decbuf = (uint8_t *) calloc( _decbuf_len, sizeof(uint8_t) ); if( NULL == _decbuf ) { printf( "Error: Failed to allocate memory.\n" ); free( _text ); free( _encbuf ); return EXIT_FAILURE; } if( OAES_RET_SUCCESS != oaes_decrypt( ctx, _encbuf, _encbuf_len, _decbuf, &_decbuf_len ) ) printf("Error: Decryption failed.\n"); if( OAES_RET_SUCCESS != oaes_free( &ctx ) ) printf("Error: Failed to uninitialize OAES.\n"); oaes_sprintf( NULL, &_buf_len, _encbuf, _encbuf_len ); _buf = (char *) calloc(_buf_len, sizeof(char)); printf( "\n***** cyphertext *****\n" ); if( _buf ) { oaes_sprintf( _buf, &_buf_len, _encbuf, _encbuf_len ); printf( "%s", _buf ); } printf( "\n**********************\n" ); free( _buf ); oaes_sprintf( NULL, &_buf_len, _decbuf, _decbuf_len ); _buf = (char *) calloc(_buf_len, sizeof( char)); printf( "\n***** plaintext *****\n" ); if( _buf ) { oaes_sprintf( _buf, &_buf_len, _decbuf, _decbuf_len ); printf( "%s", _buf ); } printf( "\n**********************\n\n" ); free( _buf ); free( _encbuf ); free( _decbuf ); free( _text ); return (EXIT_SUCCESS); }