/*
* Compile commandline: cc -std=gnu99 -Wall -Wextra -Os -o cpass pass.c
* Source code: https://04d.co/dl/software/pass.c
* License: public domain
* TODO: Implement GPGME, support for Windows
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <dirent.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#define defaultPasswordLength 25
#define VER "0.4"

/* Creates a new file or overrides an existing one with a user chosen password */
void createPass(char* path)
{
       /* Check if file already exists, if so prompt for override */
       struct stat st;
       if(stat(path, &st) == 0)
       {
               char choice;
               printf("Password already exists, override? (y/N): ");
               scanf("%c", &choice);
               if(choice == 'Y' || choice == 'y') {}
               else
               {
                       printf("Aborting\n");
                       exit(EXIT_SUCCESS);
               }
       }

       /* Create a file (or empty it if it already exists) and open it for writing */
       FILE *fp = fopen(path, "w");
       if(fp == NULL)
       {
               fprintf(stderr, "Error opening file for writing: %s\n", strerror(errno));
               exit(EXIT_FAILURE);
       }

       /* Prompt for password twice, exit if both don't match */
       char* fpass = getpass("Password: ");
       char* lpass = getpass("Repeat password: ");

       if(strcmp(fpass, lpass) == 0)
       {
               fprintf(fp, "%s", fpass);
               printf("Password added\n");
       }
       else
       {
               printf("Passwords do not match, try again\n");
               exit(EXIT_SUCCESS);
       }

       /* Flush data to disk */
       fflush(fp);
       fclose(fp);
       return;
}

/* Shows a password from a user provided file */
void showPass(char* path)
{
       /* Check if file exists and open the file and read one
        * character at a time until EOF */
       struct stat st;
       FILE *fp = fopen(path, "r");
       if(stat(path, &st) == -1 || fp == NULL)
       {
               fprintf(stderr, "Error opening file: %s\n", strerror(errno));
               exit(EXIT_FAILURE);
       }

       char curChar;
       while((curChar = fgetc(fp)) != EOF)
               printf("%c", curChar);

       printf("\n");

       /* Clean up */
       fflush(fp);
       fclose(fp);
       return;
}

/* Delete a user provided file */
void deletePass(char* path)
{
       /* Check if file exists */
       struct stat st;
       if(stat(path, &st) == 0)
       {
               char choice;
               printf("Are you sure? (y/N): ");
               scanf("%c", &choice);
               if(choice == 'Y' || choice == 'y')
               {
                       if(remove(path) == 0)
                       {
                               printf("File deleted successfully\n");
                               exit(EXIT_SUCCESS);
                       }
                       else
                       {
                               fprintf(stderr, "Error deleting file: %s\n", strerror(errno));
                               exit(EXIT_FAILURE);
                       }
               }
               else
               {
                       printf("Aborting\n");
                       exit(EXIT_SUCCESS);
               }
       }
       else
       {
               fprintf(stderr, "Error deleting file: %s\n", strerror(errno));
               exit(EXIT_FAILURE);
       }

       return;
}

/* Generate a random password and write it to a user provided file */
void generatePass(char* path, unsigned int passLen)
{
       const char charSet[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890?!@#$%^&*<>()[]{}|~`,.;";
       char password[passLen+1];

       /* Check if file already exists, if so prompt for override */
       struct stat st;
       if(stat(path, &st) == 0)
       {
               char choice;
               printf("Password already exists, override? (y/N): ");
               scanf("%c", &choice);
               if(choice == 'Y' || choice == 'y') {}
               else
               {
                       printf("Aborting\n");
                       exit(EXIT_SUCCESS);
               }
       }

       /* Seed the RNG with a better source than just time(0) */
       unsigned int pid = getpid();
       struct timeval t1;
       gettimeofday(&t1, NULL);
       srand(t1.tv_usec ^ t1.tv_sec ^ pid);

       /* For every character position, pick a random char from the set */
       for(unsigned int i=0; i < passLen; i++)
       {
               unsigned int randomIndex = rand() % (sizeof(charSet) - 1);
               password[i] = charSet[randomIndex];
       }
       password[passLen] = '\0'; /* Null terminate the password */

       /* Create a file (or empty it if it already exists) and open it for writing */
       FILE *fp = fopen(path, "w");
       if(fp == NULL)
       {
               fprintf(stderr, "Error opening file for writing: %s\n", strerror(errno));
               exit(EXIT_FAILURE);
       }

       /* Write the newly generated password to a file */
       fprintf(fp, "%s", password);

       /* Flush data to disk */
       fflush(fp);
       fclose(fp);
       printf("Password added\n");
       return;
}

/* Copy or rename a password file */
void cpmvPass(char* src, char* dest, unsigned int removeSource)
{
       /* Make a buffer, source and destination pointers */
       char buf[4096];
       FILE *stream_src = fopen(src, "r");
       if(stream_src == NULL)
       {
               fprintf(stderr, "Error opening source file for reading: %s\n", strerror(errno));
               exit(EXIT_FAILURE);
       }
       FILE *stream_dest = fopen(dest, "w");
       if(stream_src == NULL)
       {
               fprintf(stderr, "Error opening destination file for writing: %s\n", strerror(errno));
               exit(EXIT_FAILURE);
       }

       /* Copy buf bytes at a time into memory and then to disk */
       while(!feof(stream_src))
       {
               size_t bytes = fread(buf, 1, sizeof(buf), stream_src);
               if(bytes)
                       fwrite(buf, 1, bytes, stream_dest);
               else
               {
                       fprintf(stderr, "Error when trying to copy bytes "
                                       "(are source and destination the same file?)\n");
                       exit(EXIT_FAILURE);
               }
       }

       fclose(stream_src);
       fflush(stream_dest);
       fclose(stream_dest);

       if(removeSource == 1)
       {
               if(remove(src) == 0)
                       printf("File moved successfully\n");
               else
                       fprintf(stderr, "Error deleting source file: %s\n", strerror(errno));

       }
       else
               printf("File copied successfully\n");

       return;
}

int main(int argc, char *argv[])
{
       const char defaultDir[] = "/.local/share/passDir";
       char* baseDir;
       /* If env variable CPASS_DIR is defined, used that instead of
        * the default "passDir" */
       if(getenv("CPASS_DIR") == NULL)
       {
               /* Create the password folder under the user's home dir by default */
               baseDir = (char*)malloc(strlen(getenv("HOME")) + strlen(defaultDir) + 1);
               strcpy(baseDir, getenv("HOME"));
               strcat(baseDir, defaultDir);
       }
       else
       {
               baseDir = (char*)malloc(strlen(getenv("CPASS_DIR")) + 1);
               strcpy(baseDir, getenv("CPASS_DIR"));
       }

       char *path, *srcPath, *destPath;

       /* Prompt to create baseDir if it doesn't exist already */
       struct stat st;
       if(stat(baseDir, &st) == -1)
       {
               char choice;
               printf("Password directory %s does not yet exist. "
                       "Do you want to create it? (y/N): ", baseDir);
               scanf("%c", &choice);
               if(choice == 'Y' || choice == 'y')
                       if(mkdir(baseDir, 0700) == 0)
                               printf("Base directory created successfully\n");
                       else
                       {
                               fprintf(stderr, "Error creating base directory: %s\n", strerror(errno));
                               exit(EXIT_FAILURE);
                       }
               else
               {
                       printf("Aborting\n");
                       exit(EXIT_SUCCESS);
               }
       }

       /* If no arguments are specified, show stored files */
       if(argc == 1)
       {
               DIR *d = opendir(baseDir);
               struct dirent *dir;
               if(d == NULL)
               {
                       fprintf(stderr, "Error opening base directory: %s\n", strerror(errno));
                       exit(EXIT_FAILURE);
               }

               while((dir = readdir(d)) != NULL)
                       printf("%s\n", dir->d_name);

               closedir(d);
       }

       else if(strcmp(argv[1], "new") == 0)
       {
               if(argc < 3)
               {
                       printf("No file name provided\n");
                       return 1;
               }
               else if(strcmp(argv[2], "new") == 0 ||
                       strcmp(argv[2], "ver") == 0 ||
                       strcmp(argv[2], "help") == 0 ||
                       strcmp(argv[2], "del") == 0 ||
                       strcmp(argv[2], "copy") == 0 ||
                       strcmp(argv[2], "move") == 0 ||
                       strcmp(argv[2], "gen") == 0)
               {
                       printf("File cannot be named after a program command\n");
                       return 1;
               }
               /* Construct a path where to write the file */
               path = (char*)malloc(strlen(baseDir) + strlen(argv[2]) + 1);
               if(path == NULL)
               {
                       fprintf(stderr, "Error allocating memory: %s\n", strerror(errno));
                       exit(EXIT_FAILURE);
               }
               sprintf(path, "%s/%s", baseDir, argv[2]);
               free(baseDir);

               /* Do the rest */
               createPass(path);

               /* Clean up memory */
               free(path);
       }
       else if(strcmp(argv[1], "gen") == 0)
       {
               if(argc < 3)
               {
                       printf("No file name provided\n");
                       return 1;
               }
               else if(strcmp(argv[2], "new") == 0 ||
                       strcmp(argv[2], "ver") == 0 ||
                       strcmp(argv[2], "help") == 0 ||
                       strcmp(argv[2], "del") == 0 ||
                       strcmp(argv[2], "copy") == 0 ||
                       strcmp(argv[2], "move") == 0 ||
                       strcmp(argv[2], "gen") == 0)
               {
                       printf("File cannot be named after a program command\n");
                       return 1;
               }
               /* Construct a path where to write the file */
               path = (char*)malloc(strlen(baseDir) + strlen(argv[2]) + 1);
               if(path == NULL)
               {
                       fprintf(stderr, "Error allocating memory: %s\n", strerror(errno));
                       exit(EXIT_FAILURE);
               }
               sprintf(path, "%s/%s", baseDir, argv[2]);
               free(baseDir);

               /* Allow choosing generated password length */
               unsigned int passLen = defaultPasswordLength;
               if(argc == 4)
               {
                       if(atoi(argv[3]) != 0) /* Check if argument contains only digits */
                       {
                               unsigned int tmp = atoi(argv[3]);
                               if(tmp > 4096) /* Check if user doesn't provide unreasonably long password length */
                               {
                                       printf("Provided length is larger than 4095, "
                                               "consider choosing a shorter password\n");
                                       exit(EXIT_FAILURE);
                               }
                               else
                                       passLen = atoi(argv[3]);
                       }
                       else
                       {
                               printf("Provided length is not a number\n");
                               exit(EXIT_FAILURE);
                       }
               }

               /* Do the rest */
               generatePass(path, passLen);

               /* Clean up memory */
               free(path);
       }
       else if(strcmp(argv[1], "del") == 0)
       {
               if(argc < 3)
               {
                       printf("No file name provided\n");
                       return 1;
               }
               /* Construct a path where to write the file */
               path = (char*)malloc(strlen(baseDir) + strlen(argv[2]) + 1);
               if(path == NULL)
               {
                       fprintf(stderr, "Error allocating memory: %s\n", strerror(errno));
                       exit(EXIT_FAILURE);
               }
               sprintf(path, "%s/%s", baseDir, argv[2]);
               free(baseDir);

               /* Do the rest */
               deletePass(path);

               /* Clean up memory */
               free(path);
       }
       else if(strcmp(argv[1], "copy") == 0 || strcmp(argv[1], "move") == 0)
       {
               if(argc < 3)
               {
                       printf("No source file name provided\n");
                       return 1;
               }
               if(argc < 4)
               {
                       printf("No destination file name provided\n");
                       return 1;
               }
               /* Construct a path where to find the source and destination file */
               srcPath = (char*)malloc(strlen(baseDir) + strlen(argv[2]) + 1);
               if(srcPath == NULL)
               {
                       fprintf(stderr, "Error allocating memory: %s\n", strerror(errno));
                       exit(EXIT_FAILURE);
               }
               destPath = (char*)malloc(strlen(baseDir) + strlen(argv[3]) + 1);
               if(destPath == NULL)
               {
                       fprintf(stderr, "Error allocating memory: %s\n", strerror(errno));
                       exit(EXIT_FAILURE);
               }
               sprintf(srcPath, "%s/%s", baseDir, argv[2]);
               sprintf(destPath, "%s/%s", baseDir, argv[3]);
               free(baseDir);

               /* Do the rest */
               if(strcmp(argv[1], "move") == 0)
                       cpmvPass(srcPath, destPath, 1);
               else
                       cpmvPass(srcPath, destPath, 0);

               /* Clean up memory */
               free(srcPath);
               free(destPath);
       }
       else if(strcmp(argv[1], "help") == 0)
               printf("Passwords are stored in %s, dictated by the presence"
                       " or absence of the CPASS_DIR environment variable.\n"
                       "%s passName\n"
                       "%s help\n"
                       "%s ver\n"
                       "%s new passName\n"
                       "%s del passName\n"
                       "%s gen passName [passLength]\n"
                       "%s copy oldName newName\n"
                       "%s move oldName newName\n",
                       baseDir, argv[0], argv[0], argv[0], argv[0], argv[0], argv[0], argv[0], argv[0]);
       else if(strcmp(argv[1], "ver") == 0)
               printf("cpass version "VER", compiled on %s at %s\n", __DATE__,__TIME__);
       else if(argc == 2)
       {
               /* Construct a path where to find the file */
               path = (char*)malloc(strlen(baseDir) + strlen(argv[1]) + 1);
               if(path == NULL)
               {
                       fprintf(stderr, "Error allocating memory: %s\n", strerror(errno));
                       exit(EXIT_FAILURE);
               }
               sprintf(path, "%s/%s", baseDir, argv[1]);
               free(baseDir);

               /* Do the rest */
               showPass(path);

               /* Clean up memory */
               free(path);
       }

       return 0;
}

You are viewing proxied material from 04d.co. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.