static int resetkey(void) { /* reset the encryption key if needed */ int s; /* return status */ /* turn off the encryption flag */ cryptflag = FALSE; /* if we are in crypt mode */ if (curbp->b_mode & MDCRYPT) { if (curbp->b_key[0] == 0) { s = set_encryption_key(FALSE, 0); if (s != TRUE) return s; } /* let others know... */ cryptflag = TRUE; /* and set up the key to be used! */ /* de-encrypt it */ myencrypt((char *) NULL, 0); myencrypt(curbp->b_key, strlen(curbp->b_key)); /* re-encrypt it...seeding it to start */ myencrypt((char *) NULL, 0); myencrypt(curbp->b_key, strlen(curbp->b_key)); } return TRUE; }
int main(int argc, char **argv) { char path[256]; getcwd(path, sizeof(path)); char buffer[256]; snprintf(buffer, sizeof buffer, "%s/%s", path, argv[2]); printf(" full path 1.0 %s\n", buffer); if (strcmp(argv[1],"-e") == 0) { myencrypt(1, buffer, argv[3]); // 1 for encryption } else { myencrypt(0, buffer, argv[3]); // 0 for decryption } return 0; }
static int check_password(const char *plaintext, const char *password) { char buf[BUFSIZE]; if (myencrypt(plaintext, strlen(plaintext), buf, sizeof(buf)) < 0) return -1; #ifdef ENCRYPT_MD5 if (strcmp(buf, password) == 0) #else if (0) #endif return 1; else return 0; }
static const char *ircservices_crypt_string(const char *key, const char *salt) { static char output[PASSMAX]; if (salt[0] == '$' && salt[1] == '1') /* this is a new pw XXX */ { myencrypt(key, strlen(key), output, PASSMAX); return output; } else { if (check_password(key, salt)) return salt; else { output[0] = '\0'; return output; } } }
/* Shortcut for encrypting a null-terminated string in place. */ static int encrypt_in_place(char *buf, int size) { return myencrypt(buf, strlen(buf), buf, size); }
/* * Open a file for writing. Return TRUE if all is well, and FALSE on error * (cannot create). */ int ffwopen(char *fn) { #if VMS int fd; if ((fd = creat(fn, 0666, "rfm=var", "rat=cr")) < 0 || (ffp = fdopen(fd, "w")) == NULL) { #else if ((ffp = fopen(fn, "w")) == NULL) { #endif mlwrite("Cannot open file for writing"); return FIOERR; } return FIOSUC; } /* * Close a file. Should look at the status in all systems. */ int ffclose(void) { /* free this since we do not need it anymore */ if (fline) { free(fline); fline = NULL; } eofflag = FALSE; #if MSDOS & CTRLZ fputc(26, ffp); /* add a ^Z at the end of the file */ #endif #if V7 | USG | BSD | (MSDOS & (MSC | TURBO)) if (fclose(ffp) != FALSE) { mlwrite("Error closing file"); return FIOERR; } return FIOSUC; #else fclose(ffp); return FIOSUC; #endif } /* * Write a line to the already opened file. The "buf" points to the buffer, * and the "nbuf" is its length, less the free newline. Return the status. * Check only at the newline. */ int ffputline(char *buf, int nbuf) { int i; #if CRYPT char c; /* character to translate */ if (cryptflag) { for (i = 0; i < nbuf; ++i) { c = buf[i] & 0xff; myencrypt(&c, 1); fputc(c, ffp); } } else for (i = 0; i < nbuf; ++i) fputc(buf[i] & 0xFF, ffp); #else for (i = 0; i < nbuf; ++i) fputc(buf[i] & 0xFF, ffp); #endif fputc('\n', ffp); if (ferror(ffp)) { mlwrite("Write I/O error"); return FIOERR; } return FIOSUC; }
/* * Read a line from a file, and store the bytes in the supplied buffer. The * "nbuf" is the length of the buffer. Complain about long lines and lines * at the end of the file that don't have a newline present. Check for I/O * errors too. Return status. */ int ffgetline(void) { int c; /* current character read */ int i; /* current index into fline */ char *tmpline; /* temp storage for expanding line */ /* if we are at the end...return it */ if (eofflag) return FIOEOF; /* dump fline if it ended up too big */ if (flen > NSTRING) { free(fline); fline = NULL; } /* if we don't have an fline, allocate one */ if (fline == NULL) if ((fline = malloc(flen = NSTRING)) == NULL) return FIOMEM; /* read the line in */ #if PKCODE if (!nullflag) { if (fgets(fline, NSTRING, ffp) == (char *) NULL) { /* EOF ? */ i = 0; c = EOF; } else { i = (int)strlen(fline); c = 0; if (i > 0) { c = fline[i - 1]; i--; } } } else { i = 0; c = fgetc(ffp); } while (c != EOF && c != '\n') { #else i = 0; while ((c = fgetc(ffp)) != EOF && c != '\n') { #endif #if PKCODE if (c) { #endif fline[i++] = c; /* if it's longer, get more room */ if (i >= flen) { if ((tmpline = malloc(flen + NSTRING)) == NULL) return FIOMEM; strncpy(tmpline, fline, flen); flen += NSTRING; free(fline); fline = tmpline; } #if PKCODE } c = fgetc(ffp); #endif } /* test for any errors that may have occured */ if (c == EOF) { if (ferror(ffp)) { mlwrite("File read error"); return FIOERR; } if (i != 0) eofflag = TRUE; else return FIOEOF; } /* terminate and decrypt the string */ fline[i] = 0; #if CRYPT if (cryptflag) myencrypt(fline, (int)strlen(fline)); #endif return FIOSUC; } /* * does <fname> exist on disk? * * char *fname; file to check for existance */ int fexist(char *fname) { FILE *fp; /* try to open the file for reading */ fp = fopen(fname, "r"); /* if it fails, just return false! */ if (fp == NULL) return FALSE; /* otherwise, close it and report true */ fclose(fp); return TRUE; }
int main(int argc, char **argv) { int c = -1; /* command character */ int f; /* default flag */ int n; /* numeric repeat count */ int mflag; /* negative flag on repeat */ struct buffer *bp; /* temp buffer pointer */ int firstfile; /* first file flag */ int carg; /* current arg to scan */ int startflag; /* startup executed flag */ struct buffer *firstbp = NULL; /* ptr to first buffer in cmd line */ int basec; /* c stripped of meta character */ int viewflag; /* are we starting in view mode? */ int gotoflag; /* do we need to goto a line at start? */ int gline = 0; /* if so, what line? */ int searchflag; /* Do we need to search at start? */ int saveflag; /* temp store for lastflag */ int errflag; /* C error processing? */ char bname[NBUFN]; /* buffer name of file to read */ #if CRYPT int cryptflag; /* encrypting on the way in? */ char ekey[NPAT]; /* startup encryption key */ #endif int newc; #if PKCODE & VMS (void) umask(-1); /* Use old protection (this is at wrong place). */ #endif #if PKCODE & BSD sleep(1); /* Time for window manager. */ #endif #if UNIX #ifdef SIGWINCH signal(SIGWINCH, sizesignal); #endif #endif if (argc == 2) { if (strcmp(argv[1], "--help") == 0) { usage(EXIT_FAILURE); } if (strcmp(argv[1], "--version") == 0) { version(); exit(EXIT_SUCCESS); } } /* Initialize the editor. */ vtinit(); /* Display */ edinit("main"); /* Buffers, windows */ varinit(); /* user variables */ viewflag = FALSE; /* view mode defaults off in command line */ gotoflag = FALSE; /* set to off to begin with */ searchflag = FALSE; /* set to off to begin with */ firstfile = TRUE; /* no file to edit yet */ startflag = FALSE; /* startup file not executed yet */ errflag = FALSE; /* not doing C error parsing */ #if CRYPT cryptflag = FALSE; /* no encryption by default */ #endif /* Parse the command line */ for (carg = 1; carg < argc; ++carg) { /* Process Switches */ #if PKCODE if (argv[carg][0] == '+') { gotoflag = TRUE; gline = atoi(&argv[carg][1]); } else #endif if (argv[carg][0] == '-') { switch (argv[carg][1]) { /* Process Startup macroes */ case 'a': /* process error file */ case 'A': errflag = TRUE; break; case 'e': /* -e for Edit file */ case 'E': viewflag = FALSE; break; case 'g': /* -g for initial goto */ case 'G': gotoflag = TRUE; gline = atoi(&argv[carg][2]); break; #if CRYPT case 'k': /* -k<key> for code key */ case 'K': cryptflag = TRUE; strcpy(ekey, &argv[carg][2]); break; #endif #if PKCODE case 'n': /* -n accept null chars */ case 'N': nullflag = TRUE; break; #endif case 'r': /* -r restrictive use */ case 'R': restflag = TRUE; break; case 's': /* -s for initial search string */ case 'S': searchflag = TRUE; strncpy(pat, &argv[carg][2], NPAT); break; case 'v': /* -v for View File */ case 'V': viewflag = TRUE; break; default: /* unknown switch */ /* ignore this for now */ break; } } else if (argv[carg][0] == '@') { /* Process Startup macroes */ if (startup(&argv[carg][1]) == TRUE) /* don't execute emacs.rc */ startflag = TRUE; } else { /* Process an input file */ /* set up a buffer for this file */ makename(bname, argv[carg]); unqname(bname); /* set this to inactive */ bp = bfind(bname, TRUE, 0); strcpy(bp->b_fname, argv[carg]); bp->b_active = FALSE; if (firstfile) { firstbp = bp; firstfile = FALSE; } /* set the modes appropriatly */ if (viewflag) bp->b_mode |= MDVIEW; #if CRYPT if (cryptflag) { bp->b_mode |= MDCRYPT; myencrypt((char *) NULL, 0); myencrypt(ekey, strlen(ekey)); strncpy(bp->b_key, ekey, NPAT); } #endif } } #if UNIX signal(SIGHUP, emergencyexit); signal(SIGTERM, emergencyexit); #endif /* if we are C error parsing... run it! */ if (errflag) { if (startup("error.cmd") == TRUE) startflag = TRUE; } /* if invoked with no other startup files, run the system startup file here */ if (startflag == FALSE) { startup(""); startflag = TRUE; } discmd = TRUE; /* P.K. */ /* if there are any files to read, read the first one! */ bp = bfind("main", FALSE, 0); if (firstfile == FALSE && (gflags & GFREAD)) { swbuffer(firstbp); zotbuf(bp); } else bp->b_mode |= gmode; /* Deal with startup gotos and searches */ if (gotoflag && searchflag) { update(FALSE); mlwrite("(Can not search and goto at the same time!)"); } else if (gotoflag) { if (gotoline(TRUE, gline) == FALSE) { update(FALSE); mlwrite("(Bogus goto argument)"); } } else if (searchflag) { if (forwhunt(FALSE, 0) == FALSE) update(FALSE); } /* Setup to process commands. */ lastflag = 0; /* Fake last flags. */ loop: /* Execute the "command" macro...normally null. */ saveflag = lastflag; /* Preserve lastflag through this. */ execute(META | SPEC | 'C', FALSE, 1); lastflag = saveflag; #if TYPEAH && PKCODE if (typahead()) { newc = getcmd(); update(FALSE); do { fn_t execfunc; if (c == newc && (execfunc = getbind(c)) != NULL && execfunc != insert_newline && execfunc != insert_tab) newc = getcmd(); else break; } while (typahead()); c = newc; } else { update(FALSE); c = getcmd(); } #else /* Fix up the screen */ update(FALSE); /* get the next command from the keyboard */ c = getcmd(); #endif /* if there is something on the command line, clear it */ if (mpresf != FALSE) { mlerase(); update(FALSE); #if CLRMSG if (c == ' ') /* ITS EMACS does this */ goto loop; #endif } f = FALSE; n = 1; /* do META-# processing if needed */ basec = c & ~META; /* strip meta char off if there */ if ((c & META) && ((basec >= '0' && basec <= '9') || basec == '-')) { f = TRUE; /* there is a # arg */ n = 0; /* start with a zero default */ mflag = 1; /* current minus flag */ c = basec; /* strip the META */ while ((c >= '0' && c <= '9') || (c == '-')) { if (c == '-') { /* already hit a minus or digit? */ if ((mflag == -1) || (n != 0)) break; mflag = -1; } else { n = n * 10 + (c - '0'); } if ((n == 0) && (mflag == -1)) /* lonely - */ mlwrite("Arg:"); else mlwrite("Arg: %d", n * mflag); c = getcmd(); /* get the next key */ } n = n * mflag; /* figure in the sign */ } /* do ^U repeat argument processing */ if (c == reptc) { /* ^U, start argument */ f = TRUE; n = 4; /* with argument of 4 */ mflag = 0; /* that can be discarded. */ mlwrite("Arg: 4"); while (((c = getcmd()) >= '0' && c <= '9') || c == reptc || c == '-') { if (c == reptc) if ((n > 0) == ((n * 4) > 0)) n = n * 4; else n = 1; /* * If dash, and start of argument string, set arg. * to -1. Otherwise, insert it. */ else if (c == '-') { if (mflag) break; n = 0; mflag = -1; } /* * If first digit entered, replace previous argument * with digit and set sign. Otherwise, append to arg. */ else { if (!mflag) { n = 0; mflag = 1; } n = 10 * n + c - '0'; } mlwrite("Arg: %d", (mflag >= 0) ? n : (n ? -n : -1)); } /* * Make arguments preceded by a minus sign negative and change * the special argument "^U -" to an effective "^U -1". */ if (mflag == -1) { if (n == 0) n++; n = -n; } } /* and execute the command */ execute(c, f, n); goto loop; }
int main(int argc, char const *argv[]) { myencrypt(); return 0; }