static void test_resize(void)
{
Hash_table table;
hash_table_init(&table);
for (int i = 0; i < 512; ++i) {
for (int j = 0; j < i; ++j) {
int n;
hash_table_get(&table, gen_key(j), &n);
VERIFY(n == j);
}
hash_table_set(&table, gen_key(i), i, NULL);
}
hash_table_free(&table);
}
void *
cache_fetch(cache_t *c, char *prefix, char *key, int timeout)
{
char *k = gen_key(prefix, key);
cache_value_t *v;
time_t now;
pthread_mutex_lock(&c->c_lock);
v = hashtable_search(c->c_data, k);
if (v == NULL) {
goto nomatch;
}
now = time(NULL);
if (now - v->mtime > timeout) {
v = hashtable_remove(c->c_data, k);
c->c_freevalue(v->p);
free(v);
printf("cache_fetch: removed timouted key %s\n",k);
goto nomatch;
}
v->atime = time(NULL);
pthread_mutex_unlock(&c->c_lock);
free(k);
return v->p;
nomatch:
pthread_mutex_unlock(&c->c_lock);
free(k);
return NULL;
}
int main()
{
int //source,
result,
encryption;
mpz_t RSAn,
decryption,
secret;
//初始化大数,分配内存空间
mpz_init(RSAn);
mpz_init(decryption);
mpz_init(secret);
encryption=gen_key(RSAn,decryption);
RSA_encryption('g',encryption,RSAn,secret);
result=RSA_decryption(secret,decryption,RSAn);
printf("%d %c\n",result,result);
gmp_printf("RSAn=%Zd\n",
// "encryption=%Zd\n",
// "decryption=%Zd\n",
RSAn
// encryption,
//decryption
);
//销毁大数,释放内存空间
mpz_clear(RSAn);
mpz_clear(decryption);
mpz_clear(secret);
//system("pause");
return 0;
}
static CURL* get_curl(char *url, uint url_len)
{
char *key;
uint key_len;
if (gen_key(url, url_len, &key, &key_len) == FAILURE) return NULL;
return find(key, key_len);
}
int main(int argc, char **argv) {
if(argc != 1) {
fprintf(stderr, "This command does not accept any commandline arguments.");
return 1;
}
char line[4096];
while(fgets(line, sizeof(line), stdin) != NULL) {
char *t = line;
char *m;
while((m = strchr(t, '@')) != NULL) {
fwrite(t, 1, m-t, stdout);
t = m;
if(strncmp(m, "@commands@", 10) == 0) {
gen_cmd();
t += 10;
} else if(strncmp(m, "@settings@", 10) == 0) {
gen_set();
t += 10;
} else if(strncmp(m, "@keys@", 6) == 0) {
gen_key();
t += 6;
} else {
fputc('@', stdout);
t++;
}
}
fputs(t, stdout);
}
return 0;
}
s3fs::Crypto::Crypto()
{
// FGPRINT("s3fs::Crypto Initializing a crypto object\n");
// SYSLOGERR("s3fs::Crypto Initializing a crypto object");
gen_key();
gen_iv();
}
struct dtls_context *
create_dtls_context(const char *common)
{
if (common == NULL)
return NULL;
struct dtls_context *context = (struct dtls_context *)calloc(1, sizeof *context);
if (context == NULL)
return NULL;
SSL_library_init();
OpenSSL_add_all_algorithms();
SSL_CTX *ctx = SSL_CTX_new(DTLSv1_method());
if (ctx == NULL)
goto ctx_err;
context->ctx = ctx;
// ALL:NULL:eNULL:aNULL
if (SSL_CTX_set_cipher_list(ctx, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH") != 1)
goto ctx_err;
SSL_CTX_set_read_ahead(ctx, 1); // for DTLS
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, verify_peer_certificate_cb);
EVP_PKEY *key = gen_key();
if (key == NULL)
goto ctx_err;
SSL_CTX_use_PrivateKey(ctx, key);
X509 *cert = gen_cert(key, common, 365);
if (cert == NULL)
goto ctx_err;
SSL_CTX_use_certificate(ctx, cert);
if (SSL_CTX_check_private_key(ctx) != 1)
goto ctx_err;
unsigned int len;
unsigned char buf[BUFFER_SIZE];
X509_digest(cert, EVP_sha256(), buf, &len);
char *p = context->fingerprint;
for (int i = 0; i < len; ++i) {
snprintf(p, 4, "%02X:", buf[i]);
p += 3;
}
*(p - 1) = 0;
if (0) {
ctx_err:
SSL_CTX_free(ctx);
free(context);
context = NULL;
}
return context;
}
void *
cache_fetch(cache_t *c, char *prefix, char *key, int timeout)
{
char *k = gen_key(prefix, key);
cache_value_t *v;
time_t now;
int i;
pthread_mutex_lock(&c->c_lock);
int ret;
DBT dbkey, dbdata;
//resetter minne
memset(&dbkey, 0, sizeof(DBT));
memset(&dbdata, 0, sizeof(DBT));
//legger inn key i bdb strukturen
dbkey.data = k;
dbkey.size = strlen(k);
if ((ret = c->c_data->get(c->c_data, NULL, &dbkey, &dbdata, 0)) != 0) {
printf("Diden't find key %s i db\n",dbkey.data);
goto nomatch;
}
v = ((cache_value_t *)dbdata.data);
now = time(NULL);
if (now - v->mtime > timeout && timeout!=0) {
c->c_data->del(c->c_data, NULL, &dbkey, 0);
// c->c_freevalue(v->p);
// free(v);
printf("cache_fetch: removed timouted key %s. No match\n",k);
goto nomatch;
}
pthread_mutex_unlock(&c->c_lock);
free(k);
printf("######################################\n");
printf("cache_fetch: ");
for (i=0;i<v->size;i++) {
//printf("%x",v->p[i]);
printf("%c",v->p[i]);
}
printf("\n######################################\n");
return v->p;
nomatch:
pthread_mutex_unlock(&c->c_lock);
free(k);
return NULL;
}
int check_auth(const char *mac, const char *bcdcode)
{
unsigned char mac_pub_key[13 + 1] = {0};
unsigned char check_code_bcd[13 + 1] = {0};
mac_public_code(mac_pub_key, NULL, mac);
gen_key(check_code_bcd, mac_pub_key);
if ( 0 == strcmp(check_code_bcd, bcdcode) ) return 1;
return 0;
}
int main(int argc, char **argv)
{
int ret;
unsigned char *key;
int key_length;
/* *** initialization *** */
key = NULL;
key_length = 0;
ret = 1;
/* *** check cmd line argument *** */
if(argc != 2) {
fprintf(stderr, "usage: %s <key_length>\n", argv[0]);
return -1;
}
key_length = atoi(argv[1]);
if(key_length <= 0) {
fprintf(stderr, "error: key_length must be > 0\n");
return -1;
}
/* *** allocate space for key *** */
key = (unsigned char *)malloc(key_length * sizeof(char));
if(key == NULL) {
fprintf(stderr, "error: memory allocation failed\n");
return -1;
}
/* *** generate key *** */
ret = gen_key(key, key_length);
if(ret != 0)
goto cleanup;
/* *** print the key *** */
print_hex(key, key_length, "key = ");
ret = 0;
cleanup:
/* *** cleanup and return *** */
memset(key, 0x00, key_length);
free(key);
key = NULL;
key_length = 0;
return ret;
}
void init_rng(char* fname) {
//cout << "RNG initialization" << endl;
time_t t = time(NULL);
char* keyword = new char[3];
strcpy(keyword, "RNG");
K = gen_key(keyword);
//long l_S = 0x1122334455667788;
//copy_bytes((char*)&l_S, S);
init_S(fname);
cout << "S = "; print_hex(S, BLOCK_SIZE); cout << endl;
put_timestamp(D);
cout << "D = "; print_hex(D, BLOCK_SIZE); cout << endl;
I = cipher(D, BLOCK_SIZE, K); // I = f(D, K)
cout << "I = "; print_hex(I, BLOCK_SIZE); cout << endl << endl;
}
static int encrypt_data(char *in, int len, char *out) {
unsigned char outbuf[MAX_LEN];
unsigned char temp[MAX_LEN];
unsigned char iv[IV_SIZE];
unsigned char tag[16];
unsigned char *step;
int tmplen=0, outlen=0;
// copy plain text message into temp
memset(temp,0x00,MAX_LEN);
memcpy(temp,in,len);
if (glob_key[0] == 0x00) // Generate key if its the first packet
gen_key();
RAND_bytes(iv,IV_SIZE); // Generate random IV
EVP_CIPHER_CTX *ctx;
ctx = EVP_CIPHER_CTX_new();
EVP_CIPHER_CTX_init (ctx);
EVP_EncryptInit_ex (ctx, EVP_aes_256_gcm() , NULL, (const unsigned char *)glob_key, (const unsigned char *)iv);
if (!EVP_EncryptUpdate (ctx, outbuf, &outlen, (const unsigned char *)temp, len)) {
fprintf(stderr, "[!] Error in EVP_EncryptUpdate()\n");
EVP_CIPHER_CTX_cleanup (ctx);
return 0;
}
if (!EVP_EncryptFinal_ex (ctx, outbuf + outlen, &tmplen)) {
fprintf(stderr, "[!] Error in EVP_EncryptFinal_ex()\n");
EVP_CIPHER_CTX_cleanup (ctx);
return 0;
}
EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, 16, tag);
// Add header information
out[0]=PACKET_HEADER;
step=(unsigned char *)&out[1];
memcpy(step,iv,IV_SIZE);
step+=IV_SIZE;
memcpy(step,tag,sizeof(tag));
step+=sizeof(tag);
memcpy(step,outbuf,outlen+tmplen);
EVP_CIPHER_CTX_cleanup (ctx);
return outlen+tmplen+HEADER_SIZE;
}
int main(int argc, char *argv[])
{
int i =0;
if (argc <= 1) {
fprintf(stderr,"usage keygen <key length>.\n");
exit(0);
}
char * key = gen_key((size_t)atoi(argv[1]));
fprintf(stdout, "%s", key);
fprintf(stdout, "\n");
}
static int create_master_key(char *upasswd)
{
int ret;
unsigned char mpasswd[AES_KEY_LEN];
unsigned char master_key[USER_KEY_LEN];
gen_random_blob(mpasswd, AES_KEY_LEN);
gen_key((char*)mpasswd, master_key, USER_KEY_LEN);
if ((ret = store_master_key(upasswd, master_key)) == 0) {
unlock_keystore(master_key);
}
memset(master_key, 0, USER_KEY_LEN);
memset(mpasswd, 0, AES_KEY_LEN);
return ret;
}
static int decrypt_data(char *in, int len, char *out) {
unsigned char outbuf[MAX_LEN];
unsigned char iv[IV_SIZE];
unsigned char tag[16];
char *step;
int tmplen=0, outlen=0;
memset(outbuf,0x00,MAX_LEN);
// header information
step=in+1;
memcpy(iv,step,IV_SIZE); // Extract the IV
step+=IV_SIZE;
memcpy(tag,step,16); // Extract the MAC
step+=16;
if (glob_key[0] == 0x00) // Generate key if its the first packet
gen_key();
EVP_CIPHER_CTX *ctx;
ctx = EVP_CIPHER_CTX_new();
EVP_CIPHER_CTX_init (ctx);
EVP_DecryptInit_ex (ctx, EVP_aes_256_gcm() , NULL, (const unsigned char *)glob_key, (const unsigned char *)iv);
EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_IVLEN, IV_SIZE, NULL);
if (!EVP_DecryptUpdate (ctx, outbuf, &outlen, (const unsigned char *)step, len)) {
fprintf(stderr, "[!] Error in EVP_DecryptUpdate()\n");
EVP_CIPHER_CTX_cleanup (ctx);
return 0;
}
EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, sizeof(tag), tag);
if (!EVP_DecryptFinal_ex (ctx, outbuf + outlen, &tmplen)) {
fprintf(stderr, "[!] Error in EVP_DecryptFinal_ex(). Possible foul play involved.\n");
EVP_CIPHER_CTX_cleanup (ctx);
return 0;
}
EVP_CIPHER_CTX_cleanup (ctx);
memcpy(out,outbuf,outlen+tmplen);
return len;
}
int fill (int n)
{
int i;
int rc;
Key_t key;
for (i = 0; i < n; i++) {
do {
key = gen_key();
} while (inuse_twins(key) != HT_ERR_NOT_FOUND);
rc = insert_twins(key, mk_val(key));
if (rc != 0) {
return rc;
}
}
return 0;
}
int mixp (int argc, char *argv[])
{
int n;
int i;
int rc;
int sum;
Key_t key;
int x;
if (argc > 1) {
n = atoi(argv[1]);
} else {
n = 10;
}
sum = num_recs();
for (i = 0; i < n; i++) {
if (!sum || random_percent(51)) {
do {
key = gen_key();
} while (inuse_twins(key));
rc = insert_twins(key, mk_val(key));
if (rc != 0) {
return rc;
}
++sum;
x = num_recs();
aver(sum == x);
} else {
x = urand(sum);
rc = del_ith(x);//urand(sum));
if (rc) {
return rc;
}
--sum;
x = num_recs();
aver(sum == x);
}
}
return 0;
}
int main( int argc, char * argv[] ){
unsigned char *key;
if( argc != 2 ){
printf("ERROR\n");
return 0;
}
int key_lenght = atoi(argv[1]);
key = malloc( sizeof(unsigned char) * key_lenght);
if( key == NULL )
return -1;
gen_key(key, key_lenght);
free(key);
return 0;
}
/*
* record generator
*/
static void
gen_rec(record_t *rec) //BUG #2
{
static unsigned long recno; //BUG #9
static char nxt_char = 'A';
char *pad;
int i, j;
gen_key(rec->key);
sprintf(rec->recno, "%10d", recno++);
pad = rec->pad ;
for (i = 0; i < 8; i++) {
for (j = 0; j < 10; j++ ) //BUG #6
*pad++ = nxt_char ;
nxt_char++;
if( nxt_char > 'Z' )
nxt_char = 'A';
}
pad[-2] = '\r';
pad[-1] = '\n';
}
int
cache_add(cache_t *c, char *prefix, char *key, void *value)
{
char *k;
time_t now = time(NULL);
cache_value_t *v;
/* Do we already have this cached? */
k = gen_key(prefix, key);
if (k == NULL)
return 0;
pthread_mutex_lock(&c->c_lock);
if ((v = hashtable_search(c->c_data, k)) != NULL) {
v->mtime = now;
v->atime = now;
pthread_mutex_unlock(&c->c_lock);
free(k);
return 0;
}
v = malloc(sizeof(*v));
if (v == NULL) {
pthread_mutex_unlock(&c->c_lock);
free(k);
return 0;
}
v->atime = now;
v->mtime = now;
v->p = value;
hashtable_insert(c->c_data, k, v);
pthread_mutex_unlock(&c->c_lock);
return 1;
}
int genp (int argc, char *argv[])
{
int n;
int i;
int rc;
Key_t key;
if (argc > 1) {
n = atoi(argv[1]);
} else {
n = 10;
}
for (i = 0; i < n; i++) {
do {
key = gen_key();
} while (inuse_twins(key));
rc = insert_twins(key, mk_val(key));
if (rc != 0) {
return rc;
}
}
return 0;
}
/**
* @brief get_img get image from disk mode through the request
*
* @param req the zimg request
* @param request the evhtp request
*
* @return 1 for OK, 2 for 304 needn't response buffer and -1 for failed
*/
int get_img(zimg_req_t *req, evhtp_request_t *request)
{
int result = -1;
char rsp_cache_key[CACHE_KEY_SIZE];
int fd = -1;
struct stat f_stat;
char *buff = NULL;
char *orig_buff = NULL;
MagickWand *im = NULL;
size_t len = 0;
bool to_save = true;
LOG_PRINT(LOG_DEBUG, "get_img() start processing zimg request...");
int lvl1 = str_hash(req->md5);
int lvl2 = str_hash(req->md5 + 3);
char whole_path[512];
snprintf(whole_path, 512, "%s/%d/%d/%s", settings.img_path, lvl1, lvl2, req->md5);
LOG_PRINT(LOG_DEBUG, "whole_path: %s", whole_path);
if(is_dir(whole_path) == -1)
{
LOG_PRINT(LOG_DEBUG, "Image %s is not existed!", req->md5);
goto err;
}
if(settings.script_on == 1 && req->type != NULL)
snprintf(rsp_cache_key, CACHE_KEY_SIZE, "%s:%s", req->md5, req->type);
else
{
if(req->proportion == 0 && req->width == 0 && req->height == 0)
str_lcpy(rsp_cache_key, req->md5, CACHE_KEY_SIZE);
else
gen_key(rsp_cache_key, req->md5, 9, req->width, req->height, req->proportion, req->gray, req->x, req->y, req->rotate, req->quality, req->fmt);
}
if(find_cache_bin(req->thr_arg, rsp_cache_key, &buff, &len) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Cache[Key: %s].", rsp_cache_key);
to_save = false;
goto done;
}
LOG_PRINT(LOG_DEBUG, "Start to Find the Image...");
char orig_path[512];
snprintf(orig_path, 512, "%s/0*0", whole_path);
LOG_PRINT(LOG_DEBUG, "0rig File Path: %s", orig_path);
char rsp_path[512];
if(settings.script_on == 1 && req->type != NULL)
snprintf(rsp_path, 512, "%s/t_%s", whole_path, req->type);
else
{
char name[128];
snprintf(name, 128, "%d*%d_p%d_g%d_%d*%d_r%d_q%d.%s", req->width, req->height,
req->proportion,
req->gray,
req->x, req->y,
req->rotate,
req->quality,
req->fmt);
if(req->width == 0 && req->height == 0 && req->proportion == 0)
{
LOG_PRINT(LOG_DEBUG, "Return original image.");
strncpy(rsp_path, orig_path, 512);
}
else
{
snprintf(rsp_path, 512, "%s/%s", whole_path, name);
}
}
LOG_PRINT(LOG_DEBUG, "Got the rsp_path: %s", rsp_path);
if((fd = open(rsp_path, O_RDONLY)) == -1)
{
im = NewMagickWand();
if (im == NULL) goto err;
int ret;
if(find_cache_bin(req->thr_arg, req->md5, &orig_buff, &len) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Orignal Image Cache[Key: %s].", req->md5);
ret = MagickReadImageBlob(im, (const unsigned char *)orig_buff, len);
if (ret != MagickTrue)
{
LOG_PRINT(LOG_DEBUG, "Open Original Image From Blob Failed! Begin to Open it From Disk.");
del_cache(req->thr_arg, req->md5);
ret = MagickReadImage(im, orig_path);
if (ret != MagickTrue)
{
LOG_PRINT(LOG_DEBUG, "Open Original Image From Disk Failed!");
goto err;
}
else
{
MagickSizeType size = MagickGetImageSize(im);
LOG_PRINT(LOG_DEBUG, "image size = %d", size);
if(size < CACHE_MAX_SIZE)
{
MagickResetIterator(im);
char *new_buff = (char *)MagickWriteImageBlob(im, &len);
if (new_buff == NULL) {
LOG_PRINT(LOG_DEBUG, "Webimg Get Original Blob Failed!");
goto err;
}
set_cache_bin(req->thr_arg, req->md5, new_buff, len);
free(new_buff);
}
}
}
}
else
{
LOG_PRINT(LOG_DEBUG, "Not Hit Original Image Cache. Begin to Open it.");
ret = MagickReadImage(im, orig_path);
if (ret != MagickTrue)
{
LOG_PRINT(LOG_DEBUG, "Open Original Image From Disk Failed! %d != %d", ret, MagickTrue);
LOG_PRINT(LOG_DEBUG, "Open Original Image From Disk Failed!");
goto err;
}
else
{
MagickSizeType size = MagickGetImageSize(im);
LOG_PRINT(LOG_DEBUG, "image size = %d", size);
if(size < CACHE_MAX_SIZE)
{
MagickResetIterator(im);
char *new_buff = (char *)MagickWriteImageBlob(im, &len);
if (new_buff == NULL) {
LOG_PRINT(LOG_DEBUG, "Webimg Get Original Blob Failed!");
goto err;
}
set_cache_bin(req->thr_arg, req->md5, new_buff, len);
free(new_buff);
}
}
}
if(settings.script_on == 1 && req->type != NULL)
ret = lua_convert(im, req);
else
ret = convert(im, req);
if(ret == -1) goto err;
if(ret == 0) to_save = false;
buff = (char *)MagickWriteImageBlob(im, &len);
if (buff == NULL) {
LOG_PRINT(LOG_DEBUG, "Webimg Get Blob Failed!");
goto err;
}
}
else
{
to_save = false;
fstat(fd, &f_stat);
size_t rlen = 0;
len = f_stat.st_size;
if(len <= 0)
{
LOG_PRINT(LOG_DEBUG, "File[%s] is Empty.", rsp_path);
goto err;
}
if((buff = (char *)malloc(len)) == NULL)
{
LOG_PRINT(LOG_DEBUG, "buff Malloc Failed!");
goto err;
}
LOG_PRINT(LOG_DEBUG, "img_size = %d", len);
if((rlen = read(fd, buff, len)) == -1)
{
LOG_PRINT(LOG_DEBUG, "File[%s] Read Failed: %s", rsp_path, strerror(errno));
goto err;
}
else if(rlen < len)
{
LOG_PRINT(LOG_DEBUG, "File[%s] Read Not Compeletly.", rsp_path);
goto err;
}
}
//LOG_PRINT(LOG_INFO, "New Image[%s]", rsp_path);
int save_new = 0;
if(to_save == true)
{
if(req->sv == 1 || settings.save_new == 1 || (settings.save_new == 2 && req->type != NULL))
{
save_new = 1;
}
}
if(save_new == 1)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] is Not Existed. Begin to Save it.", rsp_path);
if(new_img(buff, len, rsp_path) == -1)
{
LOG_PRINT(LOG_DEBUG, "New Image[%s] Save Failed!", rsp_path);
LOG_PRINT(LOG_WARNING, "fail save %s", rsp_path);
}
}
else
LOG_PRINT(LOG_DEBUG, "Image [%s] Needn't to Storage.", rsp_path);
if(len < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, rsp_cache_key, buff, len);
}
done:
if(settings.etag == 1)
{
result = zimg_etag_set(request, buff, len);
if(result == 2)
goto err;
}
result = evbuffer_add(request->buffer_out, buff, len);
if(result != -1)
{
result = 1;
}
err:
if(fd != -1)
close(fd);
if(im != NULL)
DestroyMagickWand(im);
free(buff);
free(orig_buff);
return result;
}
/*
*DES加密
*输入：plainText 16位明文（16进制）， key 16位密钥（16进制）
*输出：加密后的结果 解密后的结果 16位明文（16进制）
*/
void deDES(char* ciperText,char* key,char* result){
printf("解密数据开始！\n");
char* dataL=(char*) malloc(32*sizeof(char));//数据左半部分
char* dataR=(char*) malloc(32*sizeof(char));//数据右半部分
char* dataL_cp=(char*) malloc(32*sizeof(char));//数据左半部分拷贝
char* dataR_cp=(char*) malloc(32*sizeof(char));//数据右半部分拷贝
char* data_48=(char*) malloc(48*sizeof(char));//48位中间数据
char* data_64=(char*) malloc(64*sizeof(char));//64位初始数据初始置换后数据
char* data_64_I=(char*) malloc(64*sizeof(char));//64位初始数据
//16个48位密钥空间
char** keys =(char**) malloc(16*sizeof(char*));
for(int i=0;i<16;i++){
*(keys+i) = (char*) malloc(48*sizeof(char));
}
//得到16个48位密钥
gen_key(key,keys);
//16进制明文转换成2进制
hex2Binary(ciperText,16,data_64_I);
//初始置换
init_pmt(data_64_I,data_64);
strCopy(data_64,dataL,32);
strCopy(data_64+32,dataR,32);
//轮变换，循环16轮
for(int rc=1;rc<=16;rc++){
//printf("第%d轮数据：",rc);
//扩展置换E
pmt_E(dataR,data_48);
strCopy(dataL,dataL_cp,32);
strCopy(dataR,dataL,32);
//异或
for(int i = 0 ;i < 48;i++){
data_48[i] = data_48[i]^keys[16-rc][i];
}
//S盒置换/选择
pmt_S(data_48,dataR_cp);
//P置换
pmt_P(dataR_cp,dataR);
//异或
for(int i = 0 ;i < 32;i++){
dataR[i] = dataL_cp[i]^dataR[i];
}
binary2Hex(dataL,32);//打印左半部分
printf(" ");
binary2Hex(dataR,32);//打印右半部分
printf("\n");
}
//32位互换
strCopy(dataR,data_64_I,32);
strCopy(dataL,data_64_I+32,32);
//逆初始置换
init_pmt_reverse(data_64_I,data_64);
printf("明文为: ");
binary2Hex(data_64,result,64);
free(data_64);
free(dataL);
free(dataR);
free(dataL_cp);
free(dataR_cp);
free(data_48);
free(data_64_I);
free(keys);
}
/**
* @brief get_img_mode_db Get image from db mode backend.
*
* @param req zimg request struct
* @param buff_ptr buff pointer
* @param img_size buff size
*
* @return 1 for success and -1 for failed
*/
int get_img_mode_db(zimg_req_t *req, evhtp_request_t *request)
{
int result = -1;
char cache_key[CACHE_KEY_SIZE];
char *img_format = NULL;
char *buff_ptr = NULL;
size_t img_size;
MagickBooleanType status;
MagickWand *magick_wand = NULL;
bool got_rsp = true;
bool got_color = false;
LOG_PRINT(LOG_DEBUG, "get_img() start processing zimg request...");
if(req->gray == 1)
{
gen_key(cache_key, req->md5, 4, req->width, req->height, req->proportion, req->gray);
}
else
{
if(req->proportion == 0 && req->width == 0 && req->height == 0)
{
gen_key(cache_key, req->md5, 0);
}
else
{
gen_key(cache_key, req->md5, 3, req->width, req->height, req->proportion);
}
}
if(find_cache_bin(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Cache[Key: %s].", cache_key);
goto done;
}
LOG_PRINT(LOG_DEBUG, "Start to Find the Image...");
if(get_img_db(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Get image [%s] from backend db succ.", cache_key);
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
goto done;
}
magick_wand = NewMagickWand();
got_rsp = false;
if(req->gray == 1)
{
gen_key(cache_key, req->md5, 3, req->width, req->height, req->proportion);
if(find_cache_bin(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Color Image Cache[Key: %s, len: %d].", cache_key, img_size);
status = MagickReadImageBlob(magick_wand, buff_ptr, img_size);
free(buff_ptr);
buff_ptr = NULL;
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Color Image Cache[Key: %s] is Bad. Remove.", cache_key);
del_cache(req->thr_arg, cache_key);
}
else
{
got_color = true;
LOG_PRINT(LOG_DEBUG, "Read Image from Color Image Cache[Key: %s, len: %d] Succ. Goto Convert.", cache_key, img_size);
goto convert;
}
}
if(get_img_db(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Get color image [%s] from backend db.", cache_key);
status = MagickReadImageBlob(magick_wand, buff_ptr, img_size);
if(status == MagickTrue)
{
got_color = true;
LOG_PRINT(LOG_DEBUG, "Read Image from Color Image[%s] Succ. Goto Convert.", cache_key);
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
free(buff_ptr);
buff_ptr = NULL;
goto convert;
}
}
}
gen_key(cache_key, req->md5, 0);
if(find_cache_bin(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Cache[Key: %s].", cache_key);
}
else
{
if(get_img_db(req->thr_arg, cache_key, &buff_ptr, &img_size) == -1)
{
LOG_PRINT(LOG_DEBUG, "Get image [%s] from backend db failed.", cache_key);
goto err;
}
else if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
}
status = MagickReadImageBlob(magick_wand, buff_ptr, img_size);
free(buff_ptr);
buff_ptr = NULL;
if(status == MagickFalse)
{
ThrowWandException(magick_wand);
del_cache(req->thr_arg, cache_key);
LOG_PRINT(LOG_DEBUG, "Read image [%s] from blob failed.", cache_key);
goto err;
}
if(req->width == 0 && req->height == 0)
{
LOG_PRINT(LOG_DEBUG, "Image [%s] needn't resize. Goto Convert.", cache_key);
goto convert;
}
int width, height;
width = req->width;
height = req->height;
float owidth = MagickGetImageWidth(magick_wand);
float oheight = MagickGetImageHeight(magick_wand);
if(width <= owidth && height <= oheight)
{
if(req->proportion == 1 || (req->proportion == 0 && req->width * req->height == 0))
{
if(req->height == 0)
{
height = width * oheight / owidth;
}
else
{
width = height * owidth / oheight;
}
}
status = MagickResizeImage(magick_wand, width, height, LanczosFilter, 1.0);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Resize Failed!", cache_key);
goto err;
}
LOG_PRINT(LOG_DEBUG, "Resize img succ.");
}
else
{
got_rsp = true;
LOG_PRINT(LOG_DEBUG, "Args width/height is bigger than real size, return original image.");
}
convert:
//compress image
if(got_color == false)
{
LOG_PRINT(LOG_DEBUG, "Start to Compress the Image!");
img_format = MagickGetImageFormat(magick_wand);
LOG_PRINT(LOG_DEBUG, "Image Format is %s", img_format);
if(strcmp(img_format, "JPEG") != 0)
{
LOG_PRINT(LOG_DEBUG, "Convert Image Format from %s to JPEG.", img_format);
status = MagickSetImageFormat(magick_wand, "JPEG");
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Convert Format Failed!", cache_key);
}
LOG_PRINT(LOG_DEBUG, "Compress Image with JPEGCompression");
status = MagickSetImageCompression(magick_wand, JPEGCompression);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Compression Failed!", cache_key);
}
}
size_t quality = MagickGetImageCompressionQuality(magick_wand);
LOG_PRINT(LOG_DEBUG, "Image Compression Quality is %u.", quality);
if(quality > WAP_QUALITY)
{
quality = WAP_QUALITY;
}
LOG_PRINT(LOG_DEBUG, "Set Compression Quality to 75%.");
status = MagickSetImageCompressionQuality(magick_wand, quality);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Set Compression Quality Failed!");
}
//strip image EXIF infomation
LOG_PRINT(LOG_DEBUG, "Start to Remove Exif Infomation of the Image...");
status = MagickStripImage(magick_wand);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Remove Exif Infomation of the ImageFailed!");
}
buff_ptr = (char *)MagickGetImageBlob(magick_wand, &img_size);
if(buff_ptr == NULL)
{
LOG_PRINT(LOG_DEBUG, "Magick Get Image Blob Failed!");
goto err;
}
gen_key(cache_key, req->md5, 3, req->width, req->height, req->proportion);
if(got_rsp == false)
{
save_img_db(req->thr_arg, cache_key, buff_ptr, img_size);
}
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
if(req->gray == 1)
{
free(buff_ptr);
buff_ptr = NULL;
}
else
{
goto done;
}
}
//gray image
if(req->gray == 1)
{
LOG_PRINT(LOG_DEBUG, "Start to Remove Color!");
status = MagickSetImageColorspace(magick_wand, GRAYColorspace);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Remove Color Failed!", cache_key);
goto err;
}
LOG_PRINT(LOG_DEBUG, "Image Remove Color Finish!");
buff_ptr = (char *)MagickGetImageBlob(magick_wand, &img_size);
if(buff_ptr == NULL)
{
LOG_PRINT(LOG_DEBUG, "Magick Get Image Blob Failed!");
goto err;
}
gen_key(cache_key, req->md5, 4, req->width, req->height, req->proportion, req->gray);
if(got_rsp == false)
{
save_img_db(req->thr_arg, cache_key, buff_ptr, img_size);
}
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
}
done:
result = evbuffer_add(request->buffer_out, buff_ptr, img_size);
if(result != -1)
{
result = 1;
}
err:
if(magick_wand)
{
magick_wand=DestroyMagickWand(magick_wand);
}
if(img_format)
free(img_format);
if(buff_ptr)
free(buff_ptr);
return result;
}
/*
* This routine generates a random client key of the type
* defined by 'ka' and stores it in the client keystore.
* file.
*
* Returns:
* KEYGEN_SUCCESS or KEYGEN_ERROR.
*/
static int
client_gen_key(const char *filename, wbku_key_attr_t *ka, const char *net,
const char *cid)
{
int fd;
FILE *cli_fp = NULL;
FILE *mas_fp;
fpos_t pos;
uint8_t cli_key[WANBOOT_MAXKEYLEN];
uint8_t mas_key[WANBOOT_HMAC_KEY_SIZE];
SHA1_CTX ctx;
char cid_buf[PATH_MAX];
boolean_t exists = B_FALSE;
wbku_retcode_t ret;
/*
* If the file already exists (possibly via keymgmt), then open
* the file for update. Otherwise create it and open it for
* for writing.
*/
fd = open(filename, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
if (fd < 0) {
if (errno == EEXIST) {
cli_fp = fopen(filename, "r+");
exists = B_TRUE;
}
} else {
if ((cli_fp = fdopen(fd, "w")) == NULL) {
(void) close(fd);
}
}
if (cli_fp == NULL) {
wbku_printerr("Cannot open client keystore");
return (KEYGEN_ERROR);
}
/*
* Generate the key. Encryption keys can be generated by simply
* calling gen_key(). An HMAC SHA1 key will be generated by
* hashing the master key.
*/
switch (ka->ka_type) {
case WBKU_KEY_3DES:
case WBKU_KEY_AES_128:
if (gen_key(ka, cli_key) != KEYGEN_SUCCESS) {
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
break;
case WBKU_KEY_HMAC_SHA1:
/*
* Follow RFC 3118 Appendix A's algorithm to generate
* the HMAC/SHA1 client key.
*/
/*
* Open the master keystore for reading only.
*/
if ((mas_fp = fopen(MASTER_KEY_FILE, "r")) == NULL) {
wbku_printerr("Cannot open master keystore");
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
/*
* Find the master key.
*/
ret = wbku_find_key(mas_fp, NULL, ka, mas_key, B_TRUE);
if (ret != WBKU_SUCCESS) {
if (ret == WBKU_NOKEY) {
wbku_printerr("Cannot create a client key "
"without first creating a master key\n");
} else {
wbku_printerr("%s\n", wbku_retmsg(ret));
}
(void) fclose(mas_fp);
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
(void) fclose(mas_fp);
/*
* Now generate the client's unique ID buffer.
*/
if (strlcpy(cid_buf, net, PATH_MAX) >= PATH_MAX ||
strlcat(cid_buf, cid, PATH_MAX) >= PATH_MAX) {
wbku_printerr("Unique id for client is too big\n");
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
/*
* Hash the buffer to create the client key.
*/
HMACInit(&ctx, mas_key, WANBOOT_HMAC_KEY_SIZE);
HMACUpdate(&ctx, (uint8_t *)cid_buf, strlen(cid_buf));
HMACFinal(&ctx, mas_key, WANBOOT_HMAC_KEY_SIZE, cli_key);
break;
case WBKU_KEY_RSA:
wbku_printerr("Cannot generate RSA key using keygen\n");
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
default:
wbku_printerr("Internal error\n");
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
/*
* Look to see if a client key of this type exists and if
* it does note its position in the file.
*/
ret = WBKU_NOKEY;
if (exists) {
ret = wbku_find_key(cli_fp, &pos, ka, NULL, B_FALSE);
if (ret != WBKU_SUCCESS && ret != WBKU_NOKEY) {
wbku_printerr("%s\n", wbku_retmsg(ret));
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
}
/*
* If wbku_find_key() did not find the key position for us,
* then we should set position to the end of the file.
*/
if (ret == WBKU_NOKEY &&
(fseek(cli_fp, 0, SEEK_END) != 0 || fgetpos(cli_fp, &pos) != 0)) {
wbku_printerr("Internal error");
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
/*
* Write the key.
*/
ret = wbku_write_key(cli_fp, &pos, ka, cli_key, B_FALSE);
if (ret != WBKU_SUCCESS) {
wbku_printerr("%s\n", wbku_retmsg(ret));
(void) fclose(cli_fp);
return (KEYGEN_ERROR);
}
(void) fclose(cli_fp);
(void) printf(gettext("A new client %s key has been generated\n"),
ka->ka_str);
return (KEYGEN_SUCCESS);
}
int sign(unsigned char *output,unsigned char *input, int input_len, char *pri_key_file)
{
unsigned char * cipher = NULL;
unsigned char * k_c = NULL;
unsigned char sign[128];
int ret;
FILE *fkey;
rsa_context rsa_ctx;
havege_state prng_ctx;
cipher = (unsigned char *)malloc((32)*sizeof(char));
/* ********************** HASH controle integrite *********************** */
k_c = (unsigned char *)malloc(2*KEY_LENGTH*sizeof(unsigned char));
memset(k_c, 0, 2*KEY_LENGTH);
//generation de la clef symetrique de KEY_LENGTH bits
gen_key(k_c, KEY_LENGTH);
sha2_hmac(k_c, KEY_LENGTH, input, input_len, cipher, 0);
print_hex(k_c, KEY_LENGTH, "cle secrete utilisée pour le hash : ");
/* *** Read the private asymetric key in the file*** */
if( ( fkey = fopen( pri_key_file, "rb" ) ) == NULL ) {
ret = 1;
printf( " failed\n ! Could not open %s\n" \
" ! Please run rsa_genkey first\n\n",pri_key_file );
goto cleanup;
}
rsa_init( &rsa_ctx, RSA_PKCS_V15, 0 );
if( ( ret = mpi_read_file( &rsa_ctx.N , 16, fkey ) ) != 0 ||
( ret = mpi_read_file( &rsa_ctx.E , 16, fkey ) ) != 0 ||
( ret = mpi_read_file( &rsa_ctx.D , 16, fkey ) ) != 0 ||
( ret = mpi_read_file( &rsa_ctx.P , 16, fkey ) ) != 0 ||
( ret = mpi_read_file( &rsa_ctx.Q , 16, fkey ) ) != 0 ||
( ret = mpi_read_file( &rsa_ctx.DP, 16, fkey ) ) != 0 ||
( ret = mpi_read_file( &rsa_ctx.DQ, 16, fkey ) ) != 0 ||
( ret = mpi_read_file( &rsa_ctx.QP, 16, fkey ) ) != 0 )
{
printf( " failed\n ! mpi_read_file returned %d\n\n", ret );
goto cleanup;
}
rsa_ctx.len = ( mpi_msb( &rsa_ctx.N ) + 7 ) >> 3;
fclose( fkey );
/* *** SYM_K(key) : chiffrement RSA de la clé de chiffrement key (16) => rsa-1024 bits = 128 octets en sortie *** */
/* *** cipher = ASYM_Kpriv (Hash) *** */
havege_init(&prng_ctx);
memset(sign, 0, 128);
if( ( ret = rsa_pkcs1_encrypt( &rsa_ctx, havege_random, &prng_ctx, RSA_PRIVATE, KEY_LENGTH, cipher, sign ) ) != 0 ) {
printf( " failed\n ! rsa_pkcs1_encrypt returned %d\n\n", ret );
goto cleanup;
}
print_hex(sign, sizeof(sign), "Hash chiffrée avec RSA : ");
/* *** ASYM_Kpub (K) *** */
output = (unsigned char *) malloc( 128 * sizeof(unsigned char));
memcpy(output, sign, 128);
cleanup:
if(cipher != NULL) {
memset(cipher, 0, 32);
free(cipher);
}
if(k_c != NULL) {
memset(k_c, 0, 2*KEY_LENGTH);
free(k_c);
}
memset(&prng_ctx,0x00, sizeof(havege_state));
memset(&rsa_ctx, 0x00, sizeof(rsa_ctx));
memset(sign, 0, 128);
return ret;
}
/**
* @brief save_img Save buffer from POST requests
*
* @param thr_arg Thread arg struct.
* @param buff The char * from POST request
* @param len The length of buff
* @param md5 Parsed md5 from url
*
* @return 1 for success and -1 for fail
*/
int save_img(thr_arg_t *thr_arg, const char *buff, const int len, char *md5)
{
int result = -1;
LOG_PRINT(LOG_DEBUG, "Begin to Caculate MD5...");
md5_state_t mdctx;
md5_byte_t md_value[16];
char md5sum[33];
int i;
int h, l;
md5_init(&mdctx);
md5_append(&mdctx, (const unsigned char*)(buff), len);
md5_finish(&mdctx, md_value);
for(i=0; i<16; ++i)
{
h = md_value[i] & 0xf0;
h >>= 4;
l = md_value[i] & 0x0f;
md5sum[i * 2] = (char)((h >= 0x0 && h <= 0x9) ? (h + 0x30) : (h + 0x57));
md5sum[i * 2 + 1] = (char)((l >= 0x0 && l <= 0x9) ? (l + 0x30) : (l + 0x57));
}
md5sum[32] = '\0';
strcpy(md5, md5sum);
LOG_PRINT(LOG_DEBUG, "md5: %s", md5sum);
char cache_key[CACHE_KEY_SIZE];
char save_path[512];
char save_name[512];
gen_key(cache_key, md5sum, 0);
if(exist_cache(thr_arg, cache_key) == 1)
{
LOG_PRINT(LOG_DEBUG, "File Exist, Needn't Save.");
result = 1;
goto done;
}
LOG_PRINT(LOG_DEBUG, "exist_cache not found. Begin to Save File.");
if(settings.mode != 1)
{
if(save_img_db(thr_arg, cache_key, buff, len) == -1)
{
LOG_PRINT(LOG_DEBUG, "save_img_db failed.");
goto done;
}
else
{
LOG_PRINT(LOG_DEBUG, "save_img_db succ.");
result = 1;
goto done;
}
}
//caculate 2-level path
int lvl1 = str_hash(md5sum);
int lvl2 = str_hash(md5sum + 3);
snprintf(save_path, 512, "%s/%d/%d/%s", settings.img_path, lvl1, lvl2, md5sum);
LOG_PRINT(LOG_DEBUG, "save_path: %s", save_path);
if(is_dir(save_path) == 1)
{
LOG_PRINT(LOG_DEBUG, "Check File Exist. Needn't Save.");
goto cache;
}
if(mk_dirs(save_path) == -1)
{
LOG_PRINT(LOG_DEBUG, "save_path[%s] Create Failed!", save_path);
goto done;
}
LOG_PRINT(LOG_DEBUG, "save_path[%s] Create Finish.", save_path);
snprintf(save_name, 512, "%s/0*0", save_path);
LOG_PRINT(LOG_DEBUG, "save_name-->: %s", save_name);
if(new_img(buff, len, save_name) == -1)
{
LOG_PRINT(LOG_DEBUG, "Save Image[%s] Failed!", save_name);
goto done;
}
cache:
if(len < CACHE_MAX_SIZE)
{
gen_key(cache_key, md5sum, 0);
set_cache_bin(thr_arg, cache_key, buff, len);
}
result = 1;
done:
return result;
}
inline void get_decrypt_key(char *passwd, AES_KEY *key)
{
unsigned char user_key[USER_KEY_LEN];
gen_key(passwd, user_key, USER_KEY_LEN);
AES_set_decrypt_key(user_key, AES_KEY_LEN, key);
}
/**
* @brief get_img The function of getting a image buffer and it's length.
*
* @param req The zimg_req_t from zhttp and it has the params of a request.
* @param buff_ptr This function return image buffer in it.
* @param img_size Get_img will change this number to return the size of image buffer.
*
* @return 1 for success and -1 for fail.
*/
int get_img(zimg_req_t *req, evhtp_request_t *request)
{
int result = -1;
char cache_key[CACHE_KEY_SIZE];
char *img_format = NULL;
int fd = -1;
struct stat f_stat;
char *buff_ptr;
size_t img_size;
MagickBooleanType status;
MagickWand *magick_wand = NULL;
bool got_rsp = true;
bool got_color = false;
LOG_PRINT(LOG_DEBUG, "get_img() start processing zimg request...");
// to gen cache_key like this: 926ee2f570dc50b2575e35a6712b08ce:0:0:1:0
gen_key(cache_key, req->md5, 4, req->width, req->height, req->proportion, req->gray);
if(find_cache_bin(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Cache[Key: %s].", cache_key);
goto done;
}
LOG_PRINT(LOG_DEBUG, "Start to Find the Image...");
char whole_path[512];
int lvl1 = str_hash(req->md5);
int lvl2 = str_hash(req->md5 + 3);
snprintf(whole_path, 512, "%s/%d/%d/%s", settings.img_path, lvl1, lvl2, req->md5);
LOG_PRINT(LOG_DEBUG, "docroot: %s", settings.img_path);
LOG_PRINT(LOG_DEBUG, "req->md5: %s", req->md5);
LOG_PRINT(LOG_DEBUG, "whole_path: %s", whole_path);
char name[128];
if(req->proportion && req->gray)
snprintf(name, 128, "%d*%dpg", req->width, req->height);
else if(req->proportion && !req->gray)
snprintf(name, 128, "%d*%dp", req->width, req->height);
else if(!req->proportion && req->gray)
snprintf(name, 128, "%d*%dg", req->width, req->height);
else
snprintf(name, 128, "%d*%d", req->width, req->height);
char color_name[128];
if(req->proportion)
snprintf(color_name, 128, "%d*%dp", req->width, req->height);
else
snprintf(color_name, 128, "%d*%d", req->width, req->height);
char orig_path[512];
snprintf(orig_path, strlen(whole_path) + 6, "%s/0*0", whole_path);
LOG_PRINT(LOG_DEBUG, "0rig File Path: %s", orig_path);
char rsp_path[512];
if(req->width == 0 && req->height == 0 && req->proportion == 0 && req->gray == 0)
{
LOG_PRINT(LOG_DEBUG, "Return original image.");
strncpy(rsp_path, orig_path, 512);
}
else
{
snprintf(rsp_path, 512, "%s/%s", whole_path, name);
}
LOG_PRINT(LOG_DEBUG, "Got the rsp_path: %s", rsp_path);
char color_path[512];
snprintf(color_path, 512, "%s/%s", whole_path, color_name);
//status=MagickReadImage(magick_wand, rsp_path);
if((fd = open(rsp_path, O_RDONLY)) == -1)
{
magick_wand = NewMagickWand();
got_rsp = false;
if(req->gray == 1)
{
gen_key(cache_key, req->md5, 3, req->width, req->height, req->proportion);
if(find_cache_bin(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Color Image Cache[Key: %s, len: %d].", cache_key, img_size);
status = MagickReadImageBlob(magick_wand, buff_ptr, img_size);
free(buff_ptr);
buff_ptr = NULL;
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Color Image Cache[Key: %s] is Bad. Remove.", cache_key);
del_cache(req->thr_arg, cache_key);
}
else
{
got_color = true;
LOG_PRINT(LOG_DEBUG, "Read Image from Color Image Cache[Key: %s, len: %d] Succ. Goto Convert.", cache_key, img_size);
goto convert;
}
}
status=MagickReadImage(magick_wand, color_path);
if(status == MagickTrue)
{
got_color = true;
LOG_PRINT(LOG_DEBUG, "Read Image from Color Image[%s] Succ. Goto Convert.", rsp_path);
buff_ptr = (char *)MagickGetImageBlob(magick_wand, &img_size);
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
free(buff_ptr);
buff_ptr = NULL;
goto convert;
}
}
// to gen cache_key like this: rsp_path-/926ee2f570dc50b2575e35a6712b08ce
gen_key(cache_key, req->md5, 0);
if(find_cache_bin(req->thr_arg, cache_key, &buff_ptr, &img_size) == 1)
{
LOG_PRINT(LOG_DEBUG, "Hit Orignal Image Cache[Key: %s].", cache_key);
status = MagickReadImageBlob(magick_wand, buff_ptr, img_size);
free(buff_ptr);
buff_ptr = NULL;
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Open Original Image From Blob Failed! Begin to Open it From Disk.");
ThrowWandException(magick_wand);
del_cache(req->thr_arg, cache_key);
status = MagickReadImage(magick_wand, orig_path);
if(status == MagickFalse)
{
ThrowWandException(magick_wand);
goto err;
}
else
{
buff_ptr = (char *)MagickGetImageBlob(magick_wand, &img_size);
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
free(buff_ptr);
buff_ptr = NULL;
}
}
}
else
{
LOG_PRINT(LOG_DEBUG, "Not Hit Original Image Cache. Begin to Open it.");
status = MagickReadImage(magick_wand, orig_path);
if(status == MagickFalse)
{
ThrowWandException(magick_wand);
goto err;
}
else
{
buff_ptr = (char *)MagickGetImageBlob(magick_wand, &img_size);
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
free(buff_ptr);
buff_ptr = NULL;
}
}
int width, height;
width = req->width;
height = req->height;
if(width == 0 && height == 0)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] needn't resize. Goto Convert.", orig_path);
goto convert;
}
float owidth = MagickGetImageWidth(magick_wand);
float oheight = MagickGetImageHeight(magick_wand);
if(width <= owidth && height <= oheight)
{
if(req->proportion == 1 || (req->proportion == 0 && req->width * req->height == 0))
{
if(req->height == 0)
{
height = width * oheight / owidth;
}
else
{
width = height * owidth / oheight;
}
}
status = MagickResizeImage(magick_wand, width, height, LanczosFilter, 1.0);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Resize Failed!", orig_path);
goto err;
}
LOG_PRINT(LOG_DEBUG, "Resize img succ.");
}
else
{
// Note this strcpy because rsp_path is not useful. We needn't to save the new image.
got_rsp = true;
LOG_PRINT(LOG_DEBUG, "Args width/height is bigger than real size, return original image.");
}
}
else
{
fstat(fd, &f_stat);
size_t rlen = 0;
img_size = f_stat.st_size;
if(img_size <= 0)
{
LOG_PRINT(LOG_DEBUG, "File[%s] is Empty.", rsp_path);
goto err;
}
if((buff_ptr = (char *)malloc(img_size)) == NULL)
{
LOG_PRINT(LOG_DEBUG, "buff_ptr Malloc Failed!");
goto err;
}
LOG_PRINT(LOG_DEBUG, "img_size = %d", img_size);
if((rlen = read(fd, buff_ptr, img_size)) == -1)
{
LOG_PRINT(LOG_DEBUG, "File[%s] Read Failed.", rsp_path);
LOG_PRINT(LOG_DEBUG, "Error: %s.", strerror(errno));
goto err;
}
else if(rlen < img_size)
{
LOG_PRINT(LOG_DEBUG, "File[%s] Read Not Compeletly.", rsp_path);
goto err;
}
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
goto done;
}
convert:
if(got_color == false)
{
//compress image
LOG_PRINT(LOG_DEBUG, "Start to Compress the Image!");
img_format = MagickGetImageFormat(magick_wand);
LOG_PRINT(LOG_DEBUG, "Image Format is %s", img_format);
if(strcmp(img_format, "JPEG") != 0)
{
LOG_PRINT(LOG_DEBUG, "Convert Image Format from %s to JPEG.", img_format);
status = MagickSetImageFormat(magick_wand, "JPEG");
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Convert Format Failed!", orig_path);
}
LOG_PRINT(LOG_DEBUG, "Compress Image with JPEGCompression");
status = MagickSetImageCompression(magick_wand, JPEGCompression);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Compression Failed!", orig_path);
}
}
size_t quality = MagickGetImageCompressionQuality(magick_wand);
LOG_PRINT(LOG_DEBUG, "Image Compression Quality is %u.", quality);
if(quality > WAP_QUALITY)
{
quality = WAP_QUALITY;
}
LOG_PRINT(LOG_DEBUG, "Set Compression Quality to 75%.");
status = MagickSetImageCompressionQuality(magick_wand, quality);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Set Compression Quality Failed!");
}
//strip image EXIF infomation
LOG_PRINT(LOG_DEBUG, "Start to Remove Exif Infomation of the Image...");
status = MagickStripImage(magick_wand);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Remove Exif Infomation of the ImageFailed!");
}
buff_ptr = (char *)MagickGetImageBlob(magick_wand, &img_size);
if(buff_ptr == NULL)
{
LOG_PRINT(LOG_DEBUG, "Magick Get Image Blob Failed!");
goto err;
}
gen_key(cache_key, req->md5, 3, req->width, req->height, req->proportion);
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
if(got_rsp == false)
{
LOG_PRINT(LOG_DEBUG, "Color Image[%s] is Not Existed. Begin to Save it.", color_path);
if(new_img(buff_ptr, img_size, color_path) == -1)
{
LOG_PRINT(LOG_DEBUG, "Color Image[%s] Save Failed!", color_path);
LOG_PRINT(LOG_WARNING, "fail save %s", color_path);
}
}
if(req->gray == 1)
{
free(buff_ptr);
buff_ptr = NULL;
}
else
{
goto done;
}
}
//gray image
if(req->gray == 1)
{
LOG_PRINT(LOG_DEBUG, "Start to Remove Color!");
status = MagickSetImageColorspace(magick_wand, GRAYColorspace);
if(status == MagickFalse)
{
LOG_PRINT(LOG_DEBUG, "Image[%s] Remove Color Failed!", orig_path);
goto err;
}
LOG_PRINT(LOG_DEBUG, "Image Remove Color Finish!");
buff_ptr = (char *)MagickGetImageBlob(magick_wand, &img_size);
if(buff_ptr == NULL)
{
LOG_PRINT(LOG_DEBUG, "Magick Get Image Blob Failed!");
goto err;
}
gen_key(cache_key, req->md5, 4, req->width, req->height, req->proportion, req->gray);
if(img_size < CACHE_MAX_SIZE)
{
set_cache_bin(req->thr_arg, cache_key, buff_ptr, img_size);
}
if(got_rsp == false)
{
if(new_img(buff_ptr, img_size, rsp_path) == -1)
{
LOG_PRINT(LOG_DEBUG, "New Image[%s] Save Failed!", rsp_path);
LOG_PRINT(LOG_WARNING, "fail save %s", rsp_path);
}
}
else
LOG_PRINT(LOG_DEBUG, "Image Needn't to Storage.", rsp_path);
}
done:
result = evbuffer_add(request->buffer_out, buff_ptr, img_size);
if(result != -1)
{
result = 1;
}
err:
if(fd != -1)
close(fd);
if(magick_wand)
{
magick_wand=DestroyMagickWand(magick_wand);
}
if(img_format)
free(img_format);
if(buff_ptr)
free(buff_ptr);
return result;
}
int main(int argc, const char *argv[])
{
enum command {
INVALID = 0,
CHECK_KEY,
CALC_PUBLIC_KEY
};
enum command cmd = INVALID;
unsigned char mac[32] = {0}, key[64] = {0}, pub_key[32] = {0};
unsigned char pub_key_str[64] = {0};
int i = 1;
if ( argc < 2 ) return 1;
for ( i = 1; i < argc; i ++ ) {
if ( 0 == strcmp("-c", argv[i]) ||
0 == strcmp("-check", argv[i]) ) {
cmd = CHECK_KEY;
}
if ( 0 == strcmp("-g", argv[i]) ||
0 == strcmp("-gen", argv[i]) ) {
cmd = CALC_PUBLIC_KEY;
}
if ( 0 == strcmp("-mac", argv[i]) ) {
strncpy(mac, argv[i+1], 32);
}
if ( 0 == strcmp("-key", argv[i] ) ) {
strncpy(key, argv[i+1], 64);
}
}
if ( cmd == INVALID ) {
printf("keygen -{[c|g]|{check}|{gen}} -mac -key\n");
return 0;
}
if ( cmd == CHECK_KEY ) {
if ( mac[0] == 0 ) {
printf("need give mac address first!\n");
return 1;
}
if ( key[0] == 0 ) {
printf("need give key first!\n");
return 1;
}
if ( check_auth(mac, key) ) {
printf("key %s accepted!\n");
return 0;
} else {
printf("key %s dennied!\n");
}
} else {
if ( mac[0] == 0 ) {
printf("need give mac address first!\n");
return 1;
}
mac_public_code(pub_key, pub_key_str, mac);
gen_key(key, pub_key);
printf("pubkey: %s, key: %s\n", pub_key_str, key);
return 0;
}
return 0;
}
