void PasswordManager_ForgotDialog::FindMyPsw(CString Username, CString Email){
CString Password = _T("");
if (FindUserPassword(encryptDecrypt(Username), encryptDecrypt(Email), Password)){
SetDlgItemText(IDC_FORGOT_PSW, Password);
}
else{
CString UserDoesntExist;
UserDoesntExist.LoadString(IDS_USER_DOESNT_EXIST);
MessageBox(UserDoesntExist, 0, MB_ICONINFORMATION | MB_OK);
}
}
BOOL PasswordManager_ForgotDialog::FindUserPassword(const CString& Username, const CString& Email, CString& Password){
User rs;
rs.Open();
while (!rs.IsEOF()){
if (Username == rs.m_userUsername && Email == rs.m_userEmail) {
Password = encryptDecrypt(rs.m_userPassword);
return true;
}
rs.MoveNext();
}
return false;
}
int main (int argc, char *argv[]) {
;
printf("ENCDEC 1.1\n");
char dir[255];
if(argc < 2)
strcpy(dir,"/mnt/usbDrive/toCrypt");
else {
strcpy(dir,argv[1]);
}
char filenameIn[255];
strcpy(filenameIn,dir);
printf("%s\n",filenameIn );
char filenameOut[255];
if(strcmp(filenameIn,"/mnt/usbDrive/toCrypt") == 0) {
strcpy(filenameOut,"/mnt/usbDrive/crypted.xor");
} else if(strcmp(filenameIn,"/mnt/usbDrive/toDecrypt.xor") == 0) {
strcpy(filenameOut,"/mnt/usbDrive/decrypted");
} else {
strcpy(filenameOut,dir);
strcat(filenameOut,".xor");
}
printf("%s\n",filenameOut );
char buffIn[1024];
char buffOut[1024];
close(fopen(filenameOut,"w"));
int fd1 = open(filenameIn, O_RDONLY);
int fd2 = open(filenameOut, O_RDWR);
if(filenameIn!=NULL) {
int bytes = read(fd1, &buffIn, 1024);
printf("%s\n",buffOut);
//Crypt:
encryptDecrypt(buffIn, buffOut);
write(fd2,&buffOut,bytes);
close(fd1);
close(fd2);
} else {
//perror(filenameIn);
}
return 0;
}
int main(int argc, char *argv[]){
DIR *dir = NULL;
struct dirent *envelopDir = NULL;
dir = opendir("/media/external/");
if(dir == NULL){
printf("Error. Cannot open /media/external.\n");
exit(1);
}
printf("The directory /media/external has been properly opened.\n\n");
int fr = open("/media/external/test.txt",O_RDONLY);
int fw = open ("/media/external/encryptedFile.xor",O_WRONLY | O_CREAT);
if (fr<0){
printf("Error. Cannot open test.txt.\n");
exit(1);
}
if (fw<0){
printf("Error. Cannot write encryptedFile.xor \n");
exit(1);
}
char buffer_in[TAILLE_MAX]="";
char buffer_out[TAILLE_MAX]="";
read(fr, buffer_in, TAILLE_MAX);
encryptDecrypt(buffer_in, buffer_out);
printf("%s\n",buffer_out);
write(fw,buffer_out,TAILLE_MAX);
close(fr);
close(fw);
close(dir);
return 0;
}
std::string CXor::decryptBase64(const std::string & toDecrypt, const std::string & key)
{
return encryptDecrypt(CBase64::decode(toDecrypt), key);
}
std::string CXor::encryptBase64(const std::string & toEncrypt, const std::string & key)
{
std::string cypher = encryptDecrypt(toEncrypt, key);
return CBase64::encode((const unsigned char*)cypher.c_str(), cypher.size());
}
int main(int argc, char* argv[])
{
char hostName[200] = DEFAULT_HOSTNAME;
int port = DEFAULT_RESMGR_TPM_PORT; //DEFAULT_TPM_PORT;
TPMI_DH_OBJECT keyHandle;
TPMI_YES_NO decryptVal = NO;
TPM2B_MAX_BUFFER inData;
char outFilePath[PATH_MAX] = {0};
setbuf(stdout, NULL);
setvbuf (stdout, NULL, _IONBF, BUFSIZ);
int opt = -1;
const char *optstring = "hvk:P:D:I:o:p:d:c:X";
static struct option long_options[] = {
{"help",0,NULL,'h'},
{"version",0,NULL,'v'},
{"keyHandle",1,NULL,'k'},
{"pwdk",1,NULL,'P'},
{"decrypt",1,NULL,'D'},
{"inFile",1,NULL,'I'},
{"outFile",1,NULL,'o'},
{"port",1,NULL,'p'},
{"debugLevel",1,NULL,'d'},
{"keyContext",1,NULL,'c'},
{"passwdInHex",0,NULL,'X'},
{0,0,0,0}
};
int returnVal = 0;
int flagCnt = 0;
int h_flag = 0,
v_flag = 0,
k_flag = 0,
P_flag = 0,
I_flag = 0,
c_flag = 0,
o_flag = 0;
char *contextKeyFile = NULL;
if(argc == 1)
{
showHelp(argv[0]);
return 0;
}
while((opt = getopt_long(argc,argv,optstring,long_options,NULL)) != -1)
{
switch(opt)
{
case 'h':
h_flag = 1;
break;
case 'v':
v_flag = 1;
break;
case 'k':
if(getSizeUint32Hex(optarg,&keyHandle) != 0)
{
returnVal = -1;
break;
}
k_flag = 1;
break;
case 'P':
sessionData.hmac.t.size = sizeof(sessionData.hmac.t) - 2;
if(str2ByteStructure(optarg,&sessionData.hmac.t.size,sessionData.hmac.t.buffer) != 0)
{
returnVal = -2;
break;
}
P_flag = 1;
break;
case 'D':
if(strcmp("YES", optarg) == 0)
decryptVal = YES;
else if(strcmp("NO", optarg) == 0)
decryptVal = NO;
else
{
returnVal = -3;
showArgError(optarg, argv[0]);
break;
}
break;
case 'I':
inData.t.size = sizeof(inData) - 2;
if(loadDataFromFile(optarg, inData.t.buffer, &inData.t.size) != 0)
{
returnVal = -4;
break;
}
I_flag = 1;
break;
case 'o':
safeStrNCpy(outFilePath, optarg, sizeof(outFilePath));
if(checkOutFile(outFilePath) != 0)
{
returnVal = -5;
break;
}
o_flag = 1;
break;
case 'p':
if( getPort(optarg, &port) )
{
printf("Incorrect port number.\n");
returnVal = -6;
}
break;
case 'd':
if( getDebugLevel(optarg, &debugLevel) )
{
printf("Incorrect debug level.\n");
returnVal = -7;
}
break;
case 'c':
contextKeyFile = optarg;
if(contextKeyFile == NULL || contextKeyFile[0] == '\0')
{
returnVal = -8;
break;
}
printf("contextKeyFile = %s\n", contextKeyFile);
c_flag = 1;
break;
case 'X':
hexPasswd = true;
break;
case ':':
// printf("Argument %c needs a value!\n",optopt);
returnVal = -9;
break;
case '?':
// printf("Unknown Argument: %c\n",optopt);
returnVal = -10;
break;
//default:
// break;
}
if(returnVal)
break;
};
if(returnVal != 0)
return returnVal;
if(P_flag == 0)
sessionData.hmac.t.size = 0;
flagCnt = h_flag + v_flag + k_flag + I_flag + o_flag + c_flag;
if(flagCnt == 1)
{
if(h_flag == 1)
showHelp(argv[0]);
else if(v_flag == 1)
showVersion(argv[0]);
else
{
showArgMismatch(argv[0]);
return -11;
}
}
else if((flagCnt == 3) && (k_flag == 1 || c_flag == 1) && (I_flag == 1) && (o_flag == 1))
{
prepareTest(hostName, port, debugLevel);
if(c_flag)
returnVal = loadTpmContextFromFile(sysContext, &keyHandle, contextKeyFile);
if (returnVal == 0)
returnVal = encryptDecrypt(keyHandle, decryptVal, &inData, outFilePath);
finishTest();
if(returnVal)
return -12;
}
else
{
showArgMismatch(argv[0]);
return -13;
}
return 0;
}
int process_job(struct job *job){
int err = SUCCESS, len=0, pos =0;
char *msg = kmalloc(1024,GFP_KERNEL);
char id[3];
len = strlen("\nJob ID :");
memcpy(msg+pos,"\nJob ID :",len);
pos+=len;
sprintf(id,"%d", job->job_id);
memcpy(msg+pos,id,3);
pos+=1;
len = strlen("\nJob type :");
memcpy(msg+pos,"\nJob type :",len);
pos+=len;
if(job->job_type==ENCRYPT||job->job_type==DECRYPT){
err = encryptDecrypt(job);
len = strlen("ENCRYPT\n");
if(job->job_type==ENCRYPT)
memcpy(msg+pos,"ENCRYPT\n",len);
else
memcpy(msg+pos,"ENCRYPT\n",len);
pos+=len;
len = strlen("Infile is ") ;
memcpy(msg+pos,"Infile is ",len);
pos+=len;
len = strlen(job->infile) ;
memcpy(msg+pos,job->infile,len);
pos+=len;
len = strlen("\nOutfile is ") ;
memcpy(msg+pos,"\nOutfile is ",len);
pos+=len;
len = strlen(job->outfile) ;
memcpy(msg+pos,job->outfile,len);
pos+=len;
}
else if(job->job_type==CHECKSUM){
err = checksum(job);
len = strlen("CHECKSUM\n") ;
memcpy(msg+pos,"CHECKSUM\n",len);
pos+=len;
len = strlen("Infile is ") ;
memcpy(msg+pos,"Infile is ",len);
pos+=len;
len = strlen(job->infile) ;
memcpy(msg+pos,job->infile,len);
pos+=len;
}
else if(job->job_type==LIST){
list_queue(prod_cons_q, job);
}
len = strlen("\nStatus is ") ;
memcpy(msg+pos,"\nStatus is ",len);
pos+=len;
if(err>=SUCCESS){
len = strlen("SUCCESS") ;
memcpy(msg+pos,"SUCCESS",len);
pos+=len;
}
else {
len = strlen("FAILIURE") ;
memcpy(msg+pos,"FAILIURE",len);
pos+=len;
}
memcpy(msg+pos,"\0",1);
printk("Heyy %s", msg);
netlink(job->pid, msg);
kfree(job);
return err;
}
int main(int argc, char *argv [])
{
char ch[256];
FILE *fcrypt;
FILE *fdecrypt;
char * pathc = NULL;
char * pathd = NULL;
// parse comand line
if (argc == 1)
{
fprintf(stderr, "Invalid usage: cryptage -c path_name_crypt -d path_name_decrypt\n");
exit(EXIT_FAILURE);
}
char * options = "c:d:";
int option;
while((option = getopt(argc, argv, options)) != -1)
{
switch(option)
{
case 'c':
pathc = optarg;
break;
case 'd':
pathd = optarg;
break;
case '?':
fprintf(stderr, "Invalid option %c\n", optopt);
exit(EXIT_FAILURE);
}
}
if(pathc !=NULL){
if(!fopen(pathc,"rb")){
printf("cannot open file\n");
} /* file to read */
else{
fcrypt = fopen("/mnt/cryptedxor.txt","w"); /* file to write encrypted message */
int fdc = open(pathc, O_RDONLY);
int taille_maxc = 1000;
char buffer_inc[taille_maxc];
char buffer_outc[taille_maxc];
read(fdc, &buffer_inc, taille_maxc);
encryptDecrypt(buffer_inc, buffer_outc);
fputs(buffer_outc,fcrypt);
printf("file encrypted \n");
fclose(fcrypt);
close(fdc);
}
}
if(pathd != NULL){
if(!fopen(pathd,"rb")){
printf("cannot open file\n");
} /* file to read */
else{
fdecrypt = fopen("/mnt/decryptedxor.txt","w"); /* file to write encrypted message */
int fdd = open(pathd, O_RDONLY);
int taille_maxd = 1000;
char buffer_ind[taille_maxd];
char buffer_outd[taille_maxd];
read(fdd, &buffer_ind, taille_maxd);
encryptDecrypt(buffer_ind, buffer_outd);
fputs(buffer_outd,fdecrypt);
printf("file decrypted \n");
close(fdd);
fclose(fdecrypt);
}
}
return 0;
}
void EncryptDecryptFile::run()
{
stopped = false;
encryptDecrypt(inputFileName, outputFileName, keyFileName);
}
