Muldersoft/SlunkCrypt
Muldersoft/SlunkCrypt
1
0
Fork 0
Code Releases 6 Activity

Some code clean-up.

Browse Source
This commit is contained in:
LoRd_MuldeR 2020-10-14 21:55:39 +02:00
parent 53dcefacbb
commit 44fef04cbc
Signed by: mulder
GPG Key ID: 2B5913365F57E03F
3 changed files with 80 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -16,12 +16,12 @@ ifeq ($(DEBUG),1)
CFLAGS += -Og -g CFLAGS += -Og -g
undefine LDFLGS undefine LDFLGS
else else
CFLAGS += -O3 -static -DNDEBUG CFLAGS += -O3 -DNDEBUG
LDFLGS += -static -s LDFLGS += -static -s
endif endif
ifeq ($(OS),Windows_NT) ifeq ($(OS),Windows_NT)
CFLAGS += -municode -mconsole LDFLGS += -municode -mconsole
endif endif
# --------------------------------------------------------------------------- # ---------------------------------------------------------------------------

131
frontend/src/main.c
View File

@ -14,6 +14,7 @@
#include <ctype.h> #include <ctype.h>
#include <signal.h> #include <signal.h>
#define BUFF_SIZE 4096U
static volatile int g_interrupted = 0; static volatile int g_interrupted = 0;
static char* read_passphrase(const CHR* const file_name) static char* read_passphrase(const CHR* const file_name)
@ -24,16 +25,16 @@ static char* read_passphrase(const CHR* const file_name)
{ {
return NULL; return NULL;
} }
FILE *const fin = FOPEN(file_name, T("rb")); FILE *const file = FOPEN(file_name, T("rb"));
if (!fin) if (!file)
{ {
return NULL; return NULL;
} }
do do
{ {
if (!fgets(buffer, (int)buff_size, fin)) if (!fgets(buffer, (int)buff_size, file))
{ {
fclose(fin); fclose(file);
free(buffer); free(buffer);
return NULL; return NULL;
} }
@ -44,7 +45,7 @@ static char* read_passphrase(const CHR* const file_name)
} }
} }
while (!buffer[0U]); while (!buffer[0U]);
fclose(fin); fclose(file);
return buffer; return buffer;
} }
@ -67,46 +68,46 @@ static int weak_passphrase(const char *str)
return !strong; return !strong;
} }
static int open_files(FILE** const fin, FILE** const fout, const CHR* const input, const CHR* const output) static int open_files(FILE **const file_in, FILE **const file_out, const CHR* const input_path, const CHR* const output_path)
{ {
*fin = FOPEN(input, T("rb")); *file_in = FOPEN(input_path, T("rb"));
if (!(*fin)) if (!(*file_in))
{ {
FPUTS(T("Error: Failed to open input file for reading!\n\n"), stderr); FPUTS(T("Error: Failed to open input file for reading!\n\n"), stderr);
return 1; return 1;
} }
*fout = FOPEN(output, T("wb")); *file_out = FOPEN(output_path, T("wb"));
if (!(*fout)) if (!(*file_out))
{ {
FPUTS(T("Error: Failed to open output file for writing!\n\n"), stderr); FPUTS(T("Error: Failed to open output file for writing!\n\n"), stderr);
fclose(*fin); fclose(*file_out);
return 1; return 1;
} }
return 0; return 0;
} }
static int encrypt(const char* const passphrase, const CHR* const input, const CHR* const output) static int encrypt(const char* const passphrase, const CHR* const input_path, const CHR* const output_path)
{ {
mcrypt_t ctx = MCRYPT_NULL; mcrypt_t ctx = MCRYPT_NULL;
FILE *fin = NULL, *fout = NULL; FILE * file_in = NULL, * file_out = NULL;
int result = 1; int result = 1;
if (open_files(&fin, &fout, input, output) != 0) if (open_files(&file_in, &file_out, input_path, output_path) != 0)
{ {
goto clean_up;; goto clean_up;;
} }
const uint64_t file_size = get_file_size(fin); const uint64_t file_size = get_file_size(file_in);
if (file_size == UINT64_MAX) if (file_size == UINT64_MAX)
{ {
FPUTS(T("I/O error: Failed to determine size of input file!\n\n"), stderr); FPUTS(T("I/O error: Failed to determine size of input file!\n\n"), stderr);
goto clean_up; goto clean_up;
} }
else if (file_size < 1LL) else if (file_size < 1U)
{ {
FPUTS(T("Error: Input file is empty!\n\n"), stderr); FPUTS(T("Error: Input file is empty or an unsupported type!\n\n"), stderr);
goto clean_up; goto clean_up;
} }
@ -117,7 +118,7 @@ static int encrypt(const char* const passphrase, const CHR* const input, const C
goto clean_up; goto clean_up;
} }
if (fwrite(&seed, sizeof(uint64_t), 1U, fout) < 1U) if (fwrite(&seed, sizeof(uint64_t), 1U, file_out) < 1U)
{ {
FPUTS(T("I/O error: Failed to write seed value!\n\n"), stderr); FPUTS(T("I/O error: Failed to write seed value!\n\n"), stderr);
goto clean_up; goto clean_up;
@ -134,16 +135,13 @@ static int encrypt(const char* const passphrase, const CHR* const input, const C
clock_t clk_now, clk_update = clock(); clock_t clk_now, clk_update = clock();
uint64_t crc_actual = CRC_INITIALIZER, bytes_read = sizeof(uint64_t); uint64_t crc_actual = CRC_INITIALIZER, bytes_read = sizeof(uint64_t);
uint8_t buffer[1024U]; uint8_t buffer[BUFF_SIZE];
while ((!feof(fin)) && (bytes_read < file_size)) while (bytes_read < file_size)
{ {
const size_t count = fread(buffer, sizeof(uint8_t), 1024U, fin); const uint64_t bytes_remaining = file_size - bytes_read;
if (ferror(fin)) const size_t request_len = (bytes_remaining < BUFF_SIZE) ? ((size_t)bytes_remaining) : BUFF_SIZE;
{ const size_t count = fread(buffer, sizeof(uint8_t), request_len, file_in);
FPUTS(T("\n\nI/O error: Failed to read input data!\n\n"), stderr);
goto clean_up;
}
if (count > 0U) if (count > 0U)
{ {
crc_actual = crc64_update(crc_actual, buffer, count); crc_actual = crc64_update(crc_actual, buffer, count);
@ -153,12 +151,16 @@ static int encrypt(const char* const passphrase, const CHR* const input, const C
FPUTS(T("\n\nMCrypt error: Failed to encrypt data!\n\n"), stderr); FPUTS(T("\n\nMCrypt error: Failed to encrypt data!\n\n"), stderr);
goto clean_up; goto clean_up;
} }
if (fwrite(buffer, sizeof(uint8_t), count, fout) < count) if (fwrite(buffer, sizeof(uint8_t), count, file_out) < count)
{ {
FPUTS(T("\n\nI/O error: Failed to write encrypted data!\n\n"), stderr); FPUTS(T("\n\nI/O error: Failed to write encrypted data!\n\n"), stderr);
goto clean_up; goto clean_up;
} }
} }
if (count < request_len)
{
break; /*EOF*/
}
if ((clk_now = clock()) - clk_update > CLOCKS_PER_SEC) if ((clk_now = clock()) - clk_update > CLOCKS_PER_SEC)
{ {
FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%"), (bytes_read / ((double)file_size)) * 100.0); FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%"), (bytes_read / ((double)file_size)) * 100.0);
@ -172,7 +174,11 @@ static int encrypt(const char* const passphrase, const CHR* const input, const C
} }
} }
crc_actual = crc64_finish(crc_actual); if (ferror(file_in))
{
FPUTS(T("\n\nI/O error: Failed to read input data!\n\n"), stderr);
goto clean_up;
}
if (bytes_read < file_size) if (bytes_read < file_size)
{ {
@ -180,9 +186,10 @@ static int encrypt(const char* const passphrase, const CHR* const input, const C
goto clean_up; goto clean_up;
} }
crc_actual = crc64_finish(crc_actual);
FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%\n\n"), 100.0); FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%\n\n"), 100.0);
if (fwrite(&crc_actual, sizeof(uint64_t), 1U, fout) < 1U) if (fwrite(&crc_actual, sizeof(uint64_t), 1U, file_out) < 1U)
{ {
FPUTS(T("I/O error: Failed to write CRC checksum!\n\n"), stderr); FPUTS(T("I/O error: Failed to write CRC checksum!\n\n"), stderr);
goto clean_up; goto clean_up;
@ -200,44 +207,44 @@ clean_up:
mcrypt_free(ctx); mcrypt_free(ctx);
} }
if (fout) if (file_out)
{ {
fclose(fout); fclose(file_out);
} }
if (fin) if (file_in)
{ {
fclose(fin); fclose(file_in);
} }
return result; return result;
} }
static int decrypt(const char* const passphrase, const CHR* const input, const CHR* const output) static int decrypt(const char* const passphrase, const CHR* const input_path, const CHR* const output_path)
{ {
mcrypt_t ctx = MCRYPT_NULL; mcrypt_t ctx = MCRYPT_NULL;
FILE *fin = NULL, *fout = NULL; FILE *file_in = NULL, *file_out = NULL;
int result = 1; int result = 1;
if (open_files(&fin, &fout, input, output) != 0) if (open_files(&file_in, &file_out, input_path, output_path) != 0)
{ {
goto clean_up; goto clean_up;
} }
const uint64_t file_size = get_file_size(fin); const uint64_t file_size = get_file_size(file_in);
if (file_size == UINT64_MAX) if (file_size == UINT64_MAX)
{ {
FPUTS(T("I/O error: Failed to determine size of input file!\n\n"), stderr); FPUTS(T("I/O error: Failed to determine size of input file!\n\n"), stderr);
goto clean_up; goto clean_up;
} }
else if (file_size < 16LL) else if (file_size < 16U)
{ {
FPUTS(T("Error: Input file is too small! Truncated?\n\n"), stderr); FPUTS(T("Error: Input file is too small! Truncated?\n\n"), stderr);
goto clean_up; goto clean_up;
} }
uint64_t seed; uint64_t seed;
if (fread(&seed, sizeof(uint64_t), 1U, fin) < 1U) if (fread(&seed, sizeof(uint64_t), 1U, file_in) < 1U)
{ {
FPUTS(T("I/O error: Failed to read seed value!\n\n"), stderr); FPUTS(T("I/O error: Failed to read seed value!\n\n"), stderr);
goto clean_up; goto clean_up;
@ -254,19 +261,14 @@ static int decrypt(const char* const passphrase, const CHR* const input, const C
clock_t clk_now, clk_update = clock(); clock_t clk_now, clk_update = clock();
uint64_t crc_actual = CRC_INITIALIZER, bytes_read = sizeof(uint64_t); uint64_t crc_actual = CRC_INITIALIZER, bytes_read = sizeof(uint64_t);
uint8_t buffer[1024U]; uint8_t buffer[BUFF_SIZE];
const uint64_t read_limit = file_size - sizeof(uint64_t); const uint64_t read_limit = file_size - sizeof(uint64_t);
while ((!feof(fin)) && (bytes_read < read_limit)) while (bytes_read < read_limit)
{ {
const uint64_t bytes_remaining = read_limit - bytes_read; const uint64_t bytes_remaining = read_limit - bytes_read;
const size_t read_len = (bytes_remaining < 1024U) ? ((size_t)bytes_remaining) : 1024U; const size_t request_len = (bytes_remaining < BUFF_SIZE) ? ((size_t)bytes_remaining) : BUFF_SIZE;
const size_t count = fread(buffer, sizeof(uint8_t), read_len, fin); const size_t count = fread(buffer, sizeof(uint8_t), request_len, file_in);
if (ferror(fin))
{
FPUTS(T("\n\nI/O error: Failed to read encrypted data!\n\n"), stderr);
goto clean_up;
}
if (count > 0U) if (count > 0U)
{ {
bytes_read += count; bytes_read += count;
@ -276,12 +278,16 @@ static int decrypt(const char* const passphrase, const CHR* const input, const C
goto clean_up; goto clean_up;
} }
crc_actual = crc64_update(crc_actual, buffer, count); crc_actual = crc64_update(crc_actual, buffer, count);
if (fwrite(buffer, sizeof(uint8_t), count, fout) < count) if (fwrite(buffer, sizeof(uint8_t), count, file_out) < count)
{ {
FPUTS(T("failed!\n\nI/O error: Failed to write decrypted data!\n\n"), stderr); FPUTS(T("failed!\n\nI/O error: Failed to write decrypted data!\n\n"), stderr);
goto clean_up; goto clean_up;
} }
} }
if (count < request_len)
{
break; /*EOF*/
}
if ((clk_now = clock()) - clk_update > CLOCKS_PER_SEC) if ((clk_now = clock()) - clk_update > CLOCKS_PER_SEC)
{ {
FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%"), (bytes_read / ((double)read_limit)) * 100.0); FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%"), (bytes_read / ((double)read_limit)) * 100.0);
@ -295,7 +301,11 @@ static int decrypt(const char* const passphrase, const CHR* const input, const C
} }
} }
crc_actual = crc64_finish(crc_actual); if (ferror(file_in))
{
FPUTS(T("\n\nI/O error: Failed to read input data!\n\n"), stderr);
goto clean_up;
}
if (bytes_read < read_limit) if (bytes_read < read_limit)
{ {
@ -303,10 +313,11 @@ static int decrypt(const char* const passphrase, const CHR* const input, const C
goto clean_up; goto clean_up;
} }
crc_actual = crc64_finish(crc_actual);
FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%\n\n"), 100.0); FPRINTF(stderr, T("\b\b\b\b\b\b%5.1f%%\n\n"), 100.0);
uint64_t crc_expected; uint64_t crc_expected;
if (fread(&crc_expected, sizeof(uint64_t), 1U, fin) < 1U) if (fread(&crc_expected, sizeof(uint64_t), 1U, file_in) < 1U)
{ {
FPUTS(T("I/O error: Failed to read CRC checksum!\n\n"), stderr); FPUTS(T("I/O error: Failed to read CRC checksum!\n\n"), stderr);
goto clean_up; goto clean_up;
@ -331,14 +342,14 @@ clean_up:
mcrypt_free(ctx); mcrypt_free(ctx);
} }
if (fout) if (file_out)
{ {
fclose(fout); fclose(file_out);
} }
if (fin) if (file_in)
{ {
fclose(fin); fclose(file_in);
} }
return result; return result;
@ -439,7 +450,7 @@ int MAIN(int argc, CHR* argv[])
FPRINTF(stderr, T("MCrypt Utility (%") T(PRIstr) T("-%") T(PRIstr) T("), by LoRd_MuldeR <MuldeR2@GMX.de>\n"), OS_TYPE, CPU_ARCH); FPRINTF(stderr, T("MCrypt Utility (%") T(PRIstr) T("-%") T(PRIstr) T("), by LoRd_MuldeR <MuldeR2@GMX.de>\n"), OS_TYPE, CPU_ARCH);
FPRINTF(stderr, T("Using libMCrypt v%") T(PRIstr) T(" [%") T(PRIstr) T("]\n\n"), LIBMCRYPT_VERSION, LIBMCRYPT_BUILDNO); FPRINTF(stderr, T("Using libMCrypt v%") T(PRIstr) T(" [%") T(PRIstr) T("]\n\n"), LIBMCRYPT_VERSION, LIBMCRYPT_BUILDNO);
if ((argc > 1) && (!STRICMP(argv[1U], T("--self-test")))) if ((argc > 1) && ((!STRICMP(argv[1U], T("-t"))) || (!STRICMP(argv[1U], T("--self-test")))))
{ {
return self_test(); /*only self-test!*/ return self_test(); /*only self-test!*/
} }
@ -497,11 +508,11 @@ int MAIN(int argc, CHR* argv[])
const clock_t clk_start = clock(); const clock_t clk_start = clock();
int result = -1; int result = -1;
if (!STRICMP(command, T("--encrypt"))) if ((!STRICMP(command, T("-e"))) || (!STRICMP(command, T("--encrypt"))))
{ {
result = encrypt(passphrase_buffer, input_file, output_file); result = encrypt(passphrase_buffer, input_file, output_file);
} }
else if (!STRICMP(command, T("--decrypt"))) else if ((!STRICMP(command, T("-d"))) || (!STRICMP(command, T("--decrypt"))))
{ {
result = decrypt(passphrase_buffer, input_file, output_file); result = decrypt(passphrase_buffer, input_file, output_file);
} }
@ -511,11 +522,13 @@ int MAIN(int argc, CHR* argv[])
goto exiting; goto exiting;
} }
if (!g_interrupted)
{
FPUTS(T("--------\n\n"), stderr); FPUTS(T("--------\n\n"), stderr);
fflush(stderr); fflush(stderr);
const clock_t clk_end = clock(); const clock_t clk_end = clock();
FPRINTF(stderr, T("Operation completed after %.1f seconds.\n\n"), (clk_end - clk_start) / ((double)CLOCKS_PER_SEC)); FPRINTF(stderr, T("Operation completed after %.1f seconds.\n\n"), (clk_end - clk_start) / ((double)CLOCKS_PER_SEC));
}
exiting: exiting:

3
frontend/src/utils.c
View File

@ -84,7 +84,8 @@ uint64_t get_file_size(FILE* const file)
uint16_t file_type = stat.st_mode & S_IFMT; uint16_t file_type = stat.st_mode & S_IFMT;
if ((file_type != S_IFDIR) && (file_type != S_IFIFO)) if ((file_type != S_IFDIR) && (file_type != S_IFIFO))
{ {
return (stat.st_size >= 0LL) ? ((uint64_t)stat.st_size) : 0U; const int64_t ssize = stat.st_size;
return (ssize >= 0) ? ((uint64_t)ssize) : 0U;
} }
return 0U; return 0U;
} }