char *do_crypt (char *str, Crypt *key, int flag)
{
size_t c;
char *free_it = NULL;
c = strlen(str);
if (flag)
{
if (key->prog)
free_it = str = (char*)prog_crypt(str, &c, key, flag);
else
my_encrypt(str, c, key->key);
str = enquote_it(str, c);
}
else
{
str = dequote_it(str, &c);
if (key->prog)
str = (char*)prog_crypt(free_it = str, &c, key, flag);
else
my_decrypt(str, c, key->key);
}
new_free(&free_it);
return (str);
}
void nap_chat(int snum)
{
GetFile *gf;
unsigned char buffer[3*BIG_BUFFER_SIZE+1];
SocketList *s;
long bytesread;
char *tmp, *p;
if (!(s = get_socket(snum)) || !(gf = (GetFile *)s->info))
{
put_it("error get_socket(%d)", snum);
nap_finished_file(snum, PREMATURE_FINISH);
return;
}
if (gf->deleted)
{
if (gf->write != -1)
close(gf->write);
gf->write = -1;
if (gf->deleted++ > 5)
close_socketread(snum);
return;
}
bytesread = new_dgets(buffer, snum, 1, BIG_BUFFER_SIZE);
switch (bytesread)
{
case -1:
say("Lost DCC CHAT to %s [%s]", gf->nick,
(dgets_errno == -1) ? "Remote End Closed Connection" :
strerror(dgets_errno));
break_from_list((List **)&transfer_struct, (List *)gf);
nap_finished_file(snum, PREMATURE_FINISH);
break;
case 0:
break;
default:
tmp = buffer;
if ((p = strrchr(tmp, '\r')))
*p = 0;
if ((p = strrchr(tmp, '\n')))
*p = 0;
my_decrypt(tmp, strlen(tmp), gf->passwd);
gf->received += bytesread;
#ifdef ALLOW_DCC_COMMANDS
if ((gf->flags & NAP_DCC_COMMANDS) == NAP_DCC_COMMANDS)
{
if (!my_strnicmp(tmp, ".cmd ", 5) && *(tmp+6))
parse_line("DCC", tmp+5, NULL, 0, 0, 1);
}
#endif
put_it(FORMAT_DCC_MSG, gf->nick, gf->ip, tmp);
break;
}
}
int main(void){
char *source = (char *)malloc(24);
memcpy(source,"Welcome to LinkC Project",24);
source[24] = 0;
const char *OPENSSLKEY = "test.key";
const char *PUBLICKEY = "test_pub.key";
char *ptr_en,*ptr_de;
printf("source is :%s\n",source);
ptr_en=my_encrypt(source,PUBLICKEY);
printf("after encrypt:%s\n",ptr_en);
ptr_de=my_decrypt(ptr_en,OPENSSLKEY);
printf("after decrypt:%s\n",ptr_de);
if(ptr_en!=NULL){
free(ptr_en);
}
if(ptr_de!=NULL){
free(ptr_de);
}
return 0;
}
int wrapfs_readpage(struct file *file, struct page *page)
{
int err;
struct file *lower_file;
struct inode *inode;
mm_segment_t old_fs;
char *page_data = NULL;
mode_t orig_mode;
#ifdef WRAPFS_CRYPTO
char *decrypted_buf = NULL;
#endif
wrapfs_debug_aops(WRAPFS_SB(file->f_dentry->d_sb)->wrapfs_debug_a_ops,
"");
wrapfs_debug("");
lower_file = wrapfs_lower_file(file);
BUG_ON(lower_file == NULL);
inode = file->f_path.dentry->d_inode;
page_data = (char *) kmap(page);
/*
* Use vfs_read because some lower file systems don't have a
* readpage method, and some file systems (esp. distributed ones)
* don't like their pages to be accessed directly. Using vfs_read
* may be a little slower, but a lot safer, as the VFS does a lot of
* the necessary magic for us.
*/
lower_file->f_pos = page_offset(page);
old_fs = get_fs();
set_fs(KERNEL_DS);
/*
* generic_file_splice_write may call us on a file not opened for
* reading, so temporarily allow reading.
*/
orig_mode = lower_file->f_mode;
lower_file->f_mode |= FMODE_READ;
err = vfs_read(lower_file, page_data, PAGE_CACHE_SIZE,
&lower_file->f_pos);
lower_file->f_mode = orig_mode;
set_fs(old_fs);
#ifdef WRAPFS_CRYPTO
/* At this point, we have the entire page from lower file system in
* page_data. If WRAPFS_CRYPTO is set, we need to decrypt page_data
* and store it back in page_data. I have taken the decrypt function
* from HW1 and made necessary modifications.
*/
decrypted_buf = kmalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
if (decrypted_buf == NULL) {
wrapfs_debug("kmalloc failed!!");
kunmap(page);
err = -ENOMEM;
goto out;
}
if (my_decrypt(page_data, PAGE_CACHE_SIZE, decrypted_buf,
PAGE_CACHE_SIZE,
WRAPFS_SB(file->f_dentry->d_sb)->key,
WRAPFS_CRYPTO_KEY_LEN) < 0) {
wrapfs_debug("my_decrypt failed!!");
kunmap(page);
kfree(decrypted_buf);
err = -EINVAL;
}
memcpy(page_data, decrypted_buf, PAGE_CACHE_SIZE);
#endif
if (err >= 0 && err < PAGE_CACHE_SIZE)
memset(page_data + err, 0, PAGE_CACHE_SIZE - err);
kunmap(page);
if (err < 0)
goto out;
err = 0;
/* if vfs_read succeeded above, sync up our times */
fsstack_copy_attr_times(inode, lower_file->f_path.dentry->d_inode);
flush_dcache_page(page);
out:
if (err == 0)
SetPageUptodate(page);
else
ClearPageUptodate(page);
unlock_page(page);
wrapfs_debug_aops(WRAPFS_SB(file->f_dentry->d_sb)->wrapfs_debug_a_ops,
"err : %d", err);
return err;
}
/*
* get_file() - get a file from the server accessible via the given socket
* fd, and save it according to the save_name
*/
void get_file(int fd, char *get_name, char *save_name) {
const int MAXLINE = 10005;
/* construct message send to server,GET file */
size_t fileNameLen = strlen(get_name);
if(fileNameLen > 39) {
die("file error: ", "flie name is too long");
}
char message[105];
bzero(message, 105);
char* ptr_mes = message;
sprintf(ptr_mes,"GET\n");
ptr_mes += 4;
sprintf(ptr_mes,"%s\n",get_name);
size_t n = MAXLINE;
ssize_t nsofar;
size_t nremain = strlen(message);
ptr_mes = message;
while(nremain > 0) {
if((nsofar = write(fd,ptr_mes,nremain)) <= 0) {
if(errno != EINTR) {
die("send GET message error: ",strerror(errno));
}
nsofar = 0;
}
nremain -= nsofar;
ptr_mes += nsofar;
}
char buf[MAXLINE];
bzero(buf,MAXLINE);
nremain = n;
char* bufp = buf;
while (1) {
if ((nsofar = read(fd, bufp, nremain)) < 0) {
if (errno != EINTR)
die("read error: ", strerror(errno));
continue;
}
/* in echo, server should never EOF */
if (nsofar == 0)
die("Server error: ", "received EOF");
bufp += nsofar;
nremain -= nsofar;
if (*(bufp-1) == '\n') {
*bufp = 0;
break;
}
}
bufp = buf;
if(*bufp != 'O') {
printf("%s\n",bufp);
return ;
}
MD5_CTX c;
unsigned char _mMD5[17] = {0};
char _mmd5str[40];
char _md5str[40];
bzero(_mmd5str,40);
bzero(_md5str, 40);
MD5_Init(&c);
int i;
int count = 0;
size_t bytes = 0;
char name[40];
for(i = 0; bufp[i]; i++) {
if(bufp[i] == '\n')
count++;
/*if(count == 1) {
int k = 0;
while(bufp[k + i + 1] != '\n') {
if(bufp[k+i+1] != get_name[k])
die("get file error","file name not match");
else
k++;
}
i += k + 1;
}*/
if(count == 2) {
int k = 1;
while(bufp[i+k] >= '0' && bufp[i+k] <= '9') {
bytes = bytes * 10 + bufp[i + k] - '0';
k++;
}
i += k + 5;
}
if(count == 3) {
strncpy(_md5str,bufp + i + 1,32);
break;
}
}
char* contents = (char*)malloc(bytes + 1);
bzero(contents,bytes + 1);
nsofar = write(fd,"OK\n",3);
nsofar = read(fd,contents,bytes);
MD5_Update(&c,contents,bytes);
MD5_Final(_mMD5,&c);
char md5data[10];
for(i = 0; i < 16; ++i) {
bzero(md5data,10);
sprintf(md5data,"%02x",_mMD5[i]);
strcat(_mmd5str,md5data);
}
printf("md5_1: %s\n",_md5str);
printf("md5_2: %s\n",_mmd5str);
int flag = 1;
for(i = 0; i < 33; i++) {
if(_mmd5str[i] != _md5str[i]) {
flag = 0;
break;
}
}
if(flag) {
int file_fd = open(save_name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR );
if(file_fd < 0) {
die("creat save file error: ", strerror(errno));
}
size_t l = 0;
char* p = (char*)malloc(257);
while(l < bytes) {
bzero(p,257);
int k = 0;
for(;k < 256;k++)
p[k] = contents[l + k];
p = my_decrypt(p,OPENSSLKEY);
write(file_fd,p,strlen(p));
l += 256;
}
close(file_fd);
}
else {
die("Get file error: ","MD5 check error");
}
}
