#include <gdfontmb.h>
#include <gdfontg.h>
#include <zlib.h>
+#include <openssl/conf.h>
+#include <openssl/evp.h>
+#include <openssl/err.h>
#include "constantstrings.h"
-#define MAX_PUZZLE_SIZE 20
+#define MAX_PUZZLE_SIZE 25
#define MAX_CLUE_LENGTH 150
+#define GRID_PIXELS 37
/* Enum to define terminal colours */
enum COLOR {
DOWN=2
};
+/* for use with the player */
+enum DIRECTION {
+ DIR_FORWARD = 1,
+ DIR_BACK = -1
+};
+
typedef char String[MAX_CLUE_LENGTH];
/* The main puzzle struct type */
String clue_down[MAX_PUZZLE_SIZE][MAX_PUZZLE_SIZE];
int grid_size;
bool grid_frozen;
- char hashed_password[256];
- char salt[256];
+ char hashed_master_password[256];
+ char hashed_solution_password[256];
} Puzzle;
+/* The player data struct type - for the player app */
+typedef struct {
+ Puzzle puzzle;
+ char filename[65535];
+ bool is_loaded;
+ char char_ans[MAX_PUZZLE_SIZE][MAX_PUZZLE_SIZE];
+ int cur_row;
+ int cur_col;
+ bool solution_revealed;
+ enum ORIENTATION current_movement;
+} MainPlayerData;
+
+/* compute the hash of a password */
+void digest_message(const unsigned char *message,
+ size_t message_len, unsigned char **digest, unsigned int *digest_len)
+{
+ EVP_MD_CTX *mdctx;
+
+ if((mdctx = EVP_MD_CTX_new()) == NULL)
+ goto err;
+
+ if(1 != EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL))
+ goto err;
+
+ if(1 != EVP_DigestUpdate(mdctx, message, message_len))
+ goto err;
+
+ if((*digest = (unsigned char *)
+ OPENSSL_malloc(EVP_MD_size(EVP_sha256()))) == NULL)
+ goto err;
+
+ if(1 != EVP_DigestFinal_ex(mdctx, *digest, digest_len))
+ goto err;
+
+ EVP_MD_CTX_free(mdctx);
+ return;
+err:
+ EVP_MD_CTX_free(mdctx);
+ ERR_print_errors_fp(stderr);
+ exit (2);
+}
+
+/* convert the hashed binary password to hexadecimal representation and
+ free the hashed binary password */
+void to_hexadecimal (char *hex, unsigned char *binary_pwd, unsigned int len)
+{
+ char buf[3];
+ /* keep reference to beginning of the hashed password */
+ unsigned char *binary_pw_begin = binary_pwd;
+ for (int i = 0; i < len; i ++)
+ {
+ sprintf (buf, "%02x", (*binary_pwd)&0xff);
+ strcat (hex, buf);
+ binary_pwd ++;
+ }
+ /* free the hashed password */
+ OPENSSL_free (binary_pw_begin);
+}
+
/* get a number from the user */
int get_num ()
{
return n;
}
-/* verify password */
-bool verify_password (Puzzle *p, const char* password)
+/* verify solution password */
+bool verify_solution_password (Puzzle *p, const char* password)
{
/* no password set */
- if (strcmp (p->hashed_password, "\0") == 0)
+ if (strcmp (p->hashed_solution_password, "\0") == 0)
return true;
/* hash the user input password and compare it with the stored password */
- char* hashed_password = crypt (password, (const char *)p->salt);
+ unsigned char* hashed_sol_password;
+ unsigned int len;
+ digest_message ((const unsigned char *)password, strlen(password),
+ &hashed_sol_password, &len);
+ char hashed_hex_pwd[256] = { (char) NULL };
+ to_hexadecimal (hashed_hex_pwd, hashed_sol_password, len);
- if (strcmp (p->hashed_password, hashed_password) == 0)
+ if (strcmp (p->hashed_solution_password, hashed_hex_pwd) == 0)
+ return true;
+
+ return false;
+}
+
+
+/* verify master password */
+bool verify_master_password (Puzzle *p, const char* password)
+{
+ /* no password set */
+ if (strcmp (p->hashed_master_password, "\0") == 0)
return true;
+ /* hash the user input password and compare it with the stored password */
+ unsigned char* hashed_mas_password;
+ unsigned int len;
+ digest_message ((const unsigned char *)password, strlen(password),
+ &hashed_mas_password, &len);
+ char hashed_hex_pwd[256] = { (char) NULL };
+ to_hexadecimal (hashed_hex_pwd, hashed_mas_password, len);
+
+ if (strcmp (p->hashed_master_password, hashed_hex_pwd) == 0)
+ return true;
+
return false;
}
-/* Set or reset password for puzzle */
-void set_puzzle_password (Puzzle *p, const char *password)
+/* Set or reset solution password for puzzle */
+void set_solution_password (Puzzle *p, const char *password)
{
/* if it is a null string, reset the password */
if (strcmp (password, "\0") == 0)
+ strcpy (p->hashed_solution_password, "\0");
+ else
{
- strcpy (p->hashed_password, "\0");
- strcpy (p->salt, "\0");
+
+ unsigned char* hashedpwd;
+ unsigned int len;
+ digest_message ((const unsigned char *)password, strlen(password),
+ &hashedpwd, &len);
+ /* the hashedpwd contains binary data - we will convert it to
+ hexadecimal data and store in file */
+
+ to_hexadecimal (p->hashed_solution_password, hashedpwd, len);
}
+}
+
+/* Set or reset master password for puzzle */
+void set_master_password (Puzzle *p, const char *password)
+{
+ /* if it is a null string, reset the password */
+ if (strcmp (password, "\0") == 0)
+ strcpy (p->hashed_master_password, "\0");
else
{
- srand (time(NULL));
- char salt[256];
- sprintf (salt, "puzzle%d", rand()%1000);
- char* hashedpwd = crypt (password, (const char*)salt);
- strcpy (p->hashed_password, hashedpwd);
- strcpy (p->salt, salt);
+
+ unsigned char* hashedpwd;
+ unsigned int len;
+ digest_message ((const unsigned char *)password, strlen(password),
+ &hashedpwd, &len);
+ /* the hashedpwd contains binary data - we will convert it to
+ hexadecimal data and store in file */
+
+ to_hexadecimal (p->hashed_master_password, hashedpwd, len);
}
}
/* Output the grid to image - if answerkey is true export filled grid */
void export_grid_image (Puzzle *p, const char *filename, bool answerkey)
{
- int img_size = p->grid_size * 40;
+ int img_size = p->grid_size * GRID_PIXELS;
FILE * outfile = fopen (filename, "wb");
if (outfile == NULL)
{
}
gdImagePtr img = gdImageCreate (img_size, img_size);
- int white = gdImageColorAllocate (img, 255,255,255);
+ gdImageColorAllocate (img, 255,255,255);
int black = gdImageColorAllocate (img, 0, 0, 0);
int blue = gdImageColorAllocate (img, 0, 0, 216);
gdFontPtr sm_fnt = gdFontGetMediumBold ();
{
/* if it is a block, draw the black square */
if (p->chars[i][j] == '#')
- gdImageFilledRectangle (img, j*40, i*40, j*40+40,
- i*40+40,black);
+ gdImageFilledRectangle (img, j*GRID_PIXELS, i*GRID_PIXELS,
+ j*GRID_PIXELS+GRID_PIXELS,
+ i*GRID_PIXELS+GRID_PIXELS,black);
else
{
/* draw a regular square */
- gdImageRectangle (img, j*40, i*40, j*40+40,
- i*40+40, black);
+ gdImageRectangle (img, j*GRID_PIXELS, i*GRID_PIXELS,
+ j*GRID_PIXELS+GRID_PIXELS,
+ i*GRID_PIXELS+GRID_PIXELS, black);
/* print the numers, if it is either start across word or
a down word */
{
char str[5];
sprintf (str, "%d", p->start_across_word[i][j]);
- gdImageString (img, sm_fnt, j*40+2, i*40+2,
- (unsigned char *)str, blue);
+ gdImageString (img, sm_fnt, j*GRID_PIXELS+2,
+ i*GRID_PIXELS+2,
+ (unsigned char *)str, blue);
}
else
{
char str[5];
sprintf (str, "%d", p->start_down_word[i][j]);
- gdImageString (img, sm_fnt, j*40+2, i*40+2,
- (unsigned char *)str, blue);
+ gdImageString (img, sm_fnt, j*GRID_PIXELS+2,
+ i*GRID_PIXELS+2,
+ (unsigned char *)str, blue);
}
}
/* if answerkey is true, draw the character in the cell */
if (answerkey)
{
- gdImageChar (img, lg_fnt, j*40+15, i*40+15,
- p->chars[i][j], black);
+ gdImageChar (img, lg_fnt, j*GRID_PIXELS+15,
+ i*GRID_PIXELS+10, p->chars[i][j], black);
}
}
}
printf ("\x1B[0m");
}
+/* check if the prev row has a block or not */
+bool prev_row_block (Puzzle *p, int r, int c)
+{
+ if (r == 0)
+ return true;
+ if (p->chars[r-1][c] == '#')
+ return true;
+ return false;
+}
+
+/* check if the next row has a block or not */
+bool next_row_block (Puzzle *p, int r, int c)
+{
+ if (r == p->grid_size-1)
+ return true;
+ if (p->chars[r+1][c] == '#')
+ return true;
+ return false;
+}
+
+/* check if the prev col has a block or not */
+bool prev_col_block (Puzzle *p, int r, int c)
+{
+ if (c == 0)
+ return true;
+ if (p->chars[r][c-1] == '#')
+ return true;
+ return false;
+}
+
+/* check if the next col has a block or not */
+bool next_col_block (Puzzle *p, int r, int c)
+{
+ if (c == p->grid_size - 1)
+ return true;
+ if (p->chars[r][c+1] == '#')
+ return true;
+ return false;
+}
+
/* check if previous row is blank or not */
bool prev_row_blank (Puzzle *p, int r, int c)
{
return false;
}
-/* unfreeze the grid - mak editing possible to change words */
+/* set the current row/col to the beginning of word index (across or down) */
+void set_selection_to_word_start (MainPlayerData *app_data,
+ enum ORIENTATION orient, int word_index)
+{
+ for (int i = 0; i < app_data->puzzle.grid_size; i ++)
+ {
+ for (int j = 0; j < app_data->puzzle.grid_size; j ++)
+ {
+ if (orient == ACROSS &&
+ app_data->puzzle.start_across_word[i][j] == word_index)
+ {
+ app_data->current_movement = ACROSS;
+ app_data->cur_row = i;
+ app_data->cur_col = j;
+ break;
+ }
+ else if (orient == DOWN &&
+ app_data->puzzle.start_down_word[i][j] == word_index)
+ {
+ app_data->current_movement = DOWN;
+ app_data->cur_row = i;
+ app_data->cur_col = j;
+ break;
+ }
+ }
+ }
+}
+
+/* unfreeze the grid - make editing possible to change words */
void unfreeze_puzzle (Puzzle *p)
{
for (int i = 0; i < p->grid_size; i ++)
/* freeze the grid - make editing impossible because it finalizes the
across and down words in the grid */
void freeze_puzzle (Puzzle *p)
-{
+{
int word_num = 1;
bool across_word_start, down_word_start;
for (int i = 0; i < p->grid_size; i ++)
across_word_start = false;
down_word_start = false;
/* if it is a blank cell - cover it with a block */
- if (p->chars[i][j] == ' ')
+ if (p->chars[i][j] == ' ' || p->chars[i][j] == '#')
p->chars[i][j] = '#';
/* it is not a blank cell - check all possibilities */
else
strcpy (p->clue_down[i][j], "");
}
}
- strcpy (p->hashed_password, "\0");
- strcpy (p->salt, "\0");
+ strcpy (p->hashed_master_password, "\0");
+ strcpy (p->hashed_solution_password, "\0");
}
/* save the puzzle to a file */
-void save_puzzle (Puzzle *puzzle, const char* file) {
+void save_puzzle (Puzzle *puzzle, const char* file)
+{
FILE *outfile;
- /* First output the uncompressed contents to temp file */
+ /* First output the uncompressed contents to a temp file */
outfile = tmpfile ();
if (outfile == NULL)
{
/* whether grid is frozen or not */
fprintf (outfile, "%d\n", puzzle->grid_frozen);
/* the hashed password */
- fprintf (outfile, "%s\n", puzzle->hashed_password);
- /* the salt */
- fprintf (outfile, "%s\n", puzzle->salt);
+ fprintf (outfile, "%s\n", puzzle->hashed_master_password);
+ /* the hashed_solution_password */
+ fprintf (outfile, "%s\n", puzzle->hashed_solution_password);
/* First output the grid characters columns/rows */
for (int i = 0; i < puzzle->grid_size; i ++)
gzip compressed file */
fflush (outfile);
fseek (outfile, 0, 0);
-
+
/* now compress the file and save it to destination file */
gzFile outdestfile = gzopen (file, "wb");
if (outdestfile == NULL)
fclose (outfile);
exit (1);
}
- char buf[4096];
- while (fread (buf, sizeof(char), 4096, outfile))
+ char buf[128];
+ int num = fread (buf, sizeof(char), sizeof(char)*128, outfile);
+ while (num > 0)
{
- int res = gzwrite (outdestfile, buf, strlen (buf) );
+ int res = gzwrite (outdestfile, buf, num*sizeof(char) );
if (res == 0)
{
fprintf (stderr, "%s %s\n", ERROR_WRITING_FILE, COMPRESSED);
fclose (outfile);
exit (1);
}
+ num = fread (buf, sizeof(char), sizeof(char)*128, outfile);
}
gzclose (outdestfile);
fclose (outfile);
}
/* read the puzzle from a file */
-Puzzle load_puzzle (const char* file) {
+Puzzle load_puzzle (const char* file)
+{
/* First open the GZip file */
gzFile insourcefile = gzopen (file, "rb");
if (insourcefile == NULL)
exit (1);
}
/* Put the uncompressed content to the temp file */
- char buf[4096];
- while (gzread (insourcefile, buf, 4096))
+ char buf[128];
+ int num = 0;
+ num = gzread (insourcefile, buf, 128);
+ while (num > 0)
{
- int res = fwrite (buf, sizeof(char), strlen (buf), infile);
+ int res = fwrite (buf, 1, num, infile);
if (res == 0)
{
fprintf (stderr, "%s\n", ERROR_READING_FILE);
gzclose (insourcefile);
exit (1);
}
+ num = gzread (insourcefile, buf, 128);
}
/* Close the gzip file */
gzclose (insourcefile);
p.grid_frozen = atoi (line) == 0 ? false : true ;
fgets (line, MAX_CLUE_LENGTH + 10, infile);
if (strlen (line) != 1)
- strcpy (p.hashed_password, strtok (line, "\n"));
+ strcpy (p.hashed_master_password, strtok (line, "\n"));
else
- strcpy (p.hashed_password, "\0");
+ strcpy (p.hashed_master_password, "\0");
fgets (line, MAX_CLUE_LENGTH + 10, infile);
if (strlen (line) != 1)
- strcpy (p.salt, strtok (line, "\n"));
+ strcpy (p.hashed_solution_password, strtok (line, "\n"));
else
- strcpy (p.salt, "\0");
+ strcpy (p.hashed_solution_password, "\0");
/* read each character of the grid */
for (int i = 0; i < p.grid_size; i ++ )
printf ("\u2550");
printf ("\u2557");
reset_color (); printf ("\n");
+ set_color (fg, bg, NORMAL);
printf ("\u2551");
set_color (fg, bg, BOLD);
printf ("%-*s", padding, title);
reset_color (); printf ("\n");
}
+/* reset the player data, loading from the puzzle file */
+void reset_player_data (MainPlayerData *app_data, const char *filename)
+{
+ app_data->puzzle = load_puzzle (filename);
+
+ app_data->is_loaded = app_data->puzzle.grid_frozen;
+ app_data->cur_col = -1;
+ app_data->cur_row = -1;
+ app_data->solution_revealed = false;
+ strcpy (app_data->filename, filename);
+ /* reset the answer keys */
+ for (int i = 0; i < app_data->puzzle.grid_size; i ++)
+ for (int j = 0; j < app_data->puzzle.grid_size; j ++)
+ app_data->char_ans[i][j] = ' ';
+
+}
+
+/* save the user grid to a file */
+void save_user_data (MainPlayerData *app_data, const char *filename)
+{
+ FILE *outfile;
+ outfile = fopen (filename, "wb");
+ if (outfile == NULL)
+ {
+ fprintf (stderr, ERROR_WRITING_FILE);
+ return;
+ }
+ fprintf (outfile, "%s\n", app_data->filename);
+ for (int i = 0; i < app_data->puzzle.grid_size; i ++)
+ {
+ for (int j = 0; j < app_data->puzzle.grid_size; j ++)
+ fprintf (outfile, "%c", app_data->char_ans[i][j]);
+ fprintf (outfile, "\n");
+ }
+
+ fclose (outfile);
+}
+
+/* load the user grid from a file */
+void load_user_data (MainPlayerData *app_data, const char *filename)
+{
+ FILE *infile;
+ infile = fopen (filename, "rb");
+ if (infile == NULL)
+ {
+ fprintf (stderr, "%s\n", ERROR_READING_FILE);
+ return;
+ }
+
+ char puzzle_file_name[65535];
+ fgets (puzzle_file_name, 65535, infile);
+ reset_player_data (app_data, strtok (puzzle_file_name, "\n"));
+
+ char line[MAX_PUZZLE_SIZE+10];
+ for (int i = 0; i < app_data->puzzle.grid_size; i ++)
+ {
+ fgets (line, MAX_PUZZLE_SIZE+10, infile);
+ for (int j = 0; j < app_data->puzzle.grid_size; j ++)
+ app_data->char_ans[i][j] = line[j];
+
+ }
+ fclose (infile);
+}
+
+/* in the player app, move the current selection index left or right */
+void move_current_col (MainPlayerData *app_data, enum DIRECTION dir)
+{
+ int r = app_data->cur_row;
+ int c = app_data->cur_col;
+ if (dir == DIR_FORWARD)
+ {
+ c ++;
+ while (c < app_data->puzzle.grid_size)
+ {
+ if (app_data->puzzle.chars[r][c] == '#')
+ c ++;
+ else
+ break;
+ }
+ if (c < app_data->puzzle.grid_size)
+ app_data->cur_col = c;
+ }
+ else
+ {
+ c --;
+ while (c >= 0)
+ {
+ if (app_data->puzzle.chars[r][c] == '#')
+ c --;
+ else
+ break;
+ }
+ if (c >= 0)
+ app_data->cur_col = c;
+ }
+}
+
+/* in the player app move the current selection index up or down */
+void move_current_row (MainPlayerData *app_data, enum DIRECTION dir)
+{
+ int r = app_data->cur_row;
+ int c = app_data->cur_col;
+ if (dir == DIR_FORWARD)
+ {
+ r ++;
+ while (r < app_data->puzzle.grid_size)
+ {
+ if (app_data->puzzle.chars[r][c] == '#')
+ r ++;
+ else
+ break;
+ }
+ if (r < app_data->puzzle.grid_size)
+ app_data->cur_row = r;
+ }
+ else
+ {
+ r --;
+ while (r >= 0)
+ {
+ if (app_data->puzzle.chars[r][c] == '#')
+ r --;
+ else
+ break;
+ }
+ if (r >= 0)
+ app_data->cur_row = r;
+ }
+}
+
#endif