void ngx_http_file_cache_create_key(ngx_http_request_t *r) { size_t len; ngx_str_t *key; ngx_uint_t i; ngx_md5_t md5; ngx_http_cache_t *c; c = r->cache; len = 0; ngx_crc32_init(c->crc32); ngx_md5_init(&md5); key = c->keys.elts; for (i = 0; i < c->keys.nelts; i++) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "http cache key: \"%V\"", &key[i]); len += key[i].len; ngx_crc32_update(&c->crc32, key[i].data, key[i].len); ngx_md5_update(&md5, key[i].data, key[i].len); } c->header_start = sizeof(ngx_http_file_cache_header_t) + sizeof(ngx_http_file_cache_key) + len + 1; ngx_crc32_final(c->crc32); ngx_md5_final(c->key, &md5); }
void ngx_http_file_cache_create_key(ngx_http_request_t *r) { size_t len; ngx_str_t *key; ngx_uint_t i; ngx_md5_t md5; ngx_http_cache_t *c; c = r->cache; len = 0; ngx_crc32_init(c->crc32); //Here,we do the crc get a key! ngx_md5_init(&md5); //Here,we get the md5 key = c->keys.elts; //Means how much elements we used to caculate the key! for (i = 0; i < c->keys.nelts; i++) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "http cache key: \"%V\"", &key[i]); len += key[i].len; ngx_crc32_update(&c->crc32, key[i].data, key[i].len); //do the crc32 ngx_md5_update(&md5, key[i].data, key[i].len); //do the md5 } c->header_start = sizeof(ngx_http_file_cache_header_t) + sizeof(ngx_http_file_cache_key) + len + 1; ngx_crc32_final(c->crc32); ngx_md5_final(c->key, &md5); }
static int ngx_http_lua_ngx_md5(lua_State *L) { u_char *src; size_t slen; ngx_md5_t md5; u_char md5_buf[MD5_DIGEST_LENGTH]; u_char hex_buf[2 * sizeof(md5_buf)]; if (lua_gettop(L) != 1) { return luaL_error(L, "expecting one argument"); } if (strcmp(luaL_typename(L, 1), (char *) "nil") == 0) { src = (u_char *) ""; slen = 0; } else { src = (u_char *) luaL_checklstring(L, 1, &slen); } ngx_md5_init(&md5); ngx_md5_update(&md5, src, slen); ngx_md5_final(md5_buf, &md5); ngx_hex_dump(hex_buf, md5_buf, sizeof(md5_buf)); lua_pushlstring(L, (char *) hex_buf, sizeof(hex_buf)); return 1; }
static int ngx_http_lua_ngx_md5_bin(lua_State *L) { u_char *src; size_t slen; ngx_md5_t md5; u_char md5_buf[MD5_DIGEST_LENGTH]; if (lua_gettop(L) != 1) { return luaL_error(L, "expecting one argument"); } if (lua_isnil(L, 1)) { src = (u_char *) ""; slen = 0; } else { src = (u_char *) luaL_checklstring(L, 1, &slen); } dd("slen: %d", (int) slen); ngx_md5_init(&md5); ngx_md5_update(&md5, src, slen); ngx_md5_final(md5_buf, &md5); lua_pushlstring(L, (char *) md5_buf, sizeof(md5_buf)); return 1; }
ngx_int_t ngx_http_sticky_misc_hmac_md5(ngx_pool_t *pool, void *in, size_t len, ngx_str_t *key, ngx_str_t *digest) { u_char hash[MD5_DIGEST_LENGTH]; u_char k[MD5_CBLOCK]; ngx_md5_t md5; u_int i; digest->data = ngx_pcalloc(pool, MD5_DIGEST_LENGTH * 2); if (digest->data == NULL) { return NGX_ERROR; } digest->len = MD5_DIGEST_LENGTH * 2; ngx_memzero(k, sizeof(k)); if (key->len > MD5_CBLOCK) { ngx_md5_init(&md5); ngx_md5_update(&md5, key->data, key->len); ngx_md5_final(k, &md5); } else { ngx_memcpy(k, key->data, key->len); } /* XOR ipad */ for (i=0; i < MD5_CBLOCK; i++) { k[i] ^= 0x36; } ngx_md5_init(&md5); ngx_md5_update(&md5, k, MD5_CBLOCK); ngx_md5_update(&md5, in, len); ngx_md5_final(hash, &md5); /* Convert k to opad -- 0x6A = 0x36 ^ 0x5C */ for (i=0; i < MD5_CBLOCK; i++) { k[i] ^= 0x6a; } ngx_md5_init(&md5); ngx_md5_update(&md5, k, MD5_CBLOCK); ngx_md5_update(&md5, hash, MD5_DIGEST_LENGTH); ngx_md5_final(hash, &md5); ngx_hex_dump(digest->data, hash, MD5_DIGEST_LENGTH); return NGX_OK; }
void ngx_http_lua_ffi_md5_bin(const u_char *src, size_t len, u_char *dst) { ngx_md5_t md5; ngx_md5_init(&md5); ngx_md5_update(&md5, src, len); ngx_md5_final(dst, &md5); }
static u_char* ngx_http_upstream_consistent_md5_hash(u_char *result, const u_char *key, size_t key_length) { ngx_md5_t md5; ngx_md5_init(&md5); ngx_md5_update(&md5, key, key_length); ngx_md5_final(result, &md5); return result; }
static ngx_int_t ngx_http_md5_hash_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) { ngx_http_hash_ctx_t *ctx = (ngx_http_hash_ctx_t *)data; ngx_uint_t i; ngx_str_t val; ngx_md5_t md5; u_char hash[16], *p; if (ngx_http_complex_value(r, &ctx->value, &val) != NGX_OK) { return NGX_ERROR; } v->len = sizeof("7002945D4B8D9E472866092689DB3EAD") - 1; if (v->len <= ctx->start) { return NGX_ERROR; } if (v->len < ctx->end) { return NGX_ERROR; } v->data = ngx_palloc(r->pool, v->len); if (v->data == NULL) { v->not_found = 1; return NGX_OK; } ngx_md5_init(&md5); ngx_md5_update(&md5, val.data, val.len); ngx_md5_final((u_char*)hash, &md5); p = v->data; for (i = 0; i < 16; i++) { p = ngx_sprintf(p, "%02XD", hash[i]); } v->valid = 1; v->not_found = 0; v->no_cacheable = 0; if (ctx->end) { v->data += ctx->start; v->len = ctx->end; } return NGX_OK; }
void ngx_http_lua_ffi_md5(const u_char *src, size_t len, u_char *dst) { ngx_md5_t md5; u_char md5_buf[MD5_DIGEST_LENGTH]; ngx_md5_init(&md5); ngx_md5_update(&md5, src, len); ngx_md5_final(md5_buf, &md5); ngx_hex_dump(dst, md5_buf, sizeof(md5_buf)); }
u_char * ngx_http_lua_digest_hex(u_char *dest, const u_char *buf, int buf_len) { ngx_md5_t md5; u_char md5_buf[MD5_DIGEST_LENGTH]; ngx_md5_init(&md5); ngx_md5_update(&md5, buf, buf_len); ngx_md5_final(md5_buf, &md5); return ngx_hex_dump(dest, md5_buf, sizeof(md5_buf)); }
/* The md5 hash vaule has better random value with the input string than crc32. * And the virtual node can be dispersed uniformly in the ring. * */ static int32_t ngx_http_upstream_consistent_hash_node_point(u_char *str, size_t len) { u_char md5_buf[16]; ngx_md5_t md5; ngx_md5_init(&md5); ngx_md5_update(&md5, str, len); ngx_md5_final(md5_buf, &md5); return ngx_crc32_long(md5_buf, 16); }
static ngx_int_t ngx_http_session_gen_sid(ngx_http_request_t *r, ngx_str_t *sid) { ngx_md5_t md5_state; u_char md5_digest[16]; u_char hex_output[16 * 2 + 1], source[512]; ngx_uint_t di, source_len = 0, port_time_len; struct sockaddr_in *peer_addr; socklen_t peer_len = NGX_SOCKADDRLEN; u_char sa[NGX_SOCKADDRLEN]; ngx_int_t ret = 0; ngx_time_t *time; memset(source, 0, 512); memcpy(source, r->connection->addr_text.data, r->connection->addr_text.len); source_len += r->connection->addr_text.len; ret = getpeername(r->connection->fd, (struct sockaddr *)&sa, &peer_len); if (ret < 0) { return NGX_ERROR; } time = ngx_timeofday(); if (!time) { return NGX_ERROR; } peer_addr = (struct sockaddr_in *)sa; port_time_len = sprintf((char *)source + source_len, ":%d %d.%d", peer_addr->sin_port, (int)ngx_time(), (int)time->msec); if (port_time_len <= 0) { return NGX_ERROR; } source_len += port_time_len; ngx_md5_init(&md5_state); ngx_md5_update(&md5_state, (void *)source, source_len); ngx_md5_final(md5_digest, &md5_state); for (di = 0; di < 16; di++) { sprintf((char *)hex_output + di * 2, "%02x", md5_digest[di]); } memcpy(sid->data, hex_output, NGX_HTTP_SESSION_DEFAULT_SID_LEN); sid->data[NGX_HTTP_SESSION_DEFAULT_SID_LEN] = 0; sid->len = NGX_HTTP_SESSION_DEFAULT_SID_LEN; return NGX_OK; }
static ngx_int_t ngx_http_secure_cookie_set_md5_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) { u_char md5_buf[16]; ngx_str_t res, val; ngx_md5_t md5; ngx_http_secure_cookie_conf_t *sclcf; sclcf = ngx_http_get_module_loc_conf(r, ngx_http_secure_cookie_module); if (sclcf == NULL) { goto not_found; } if (ngx_http_complex_value(r, sclcf->md5, &val) != NGX_OK) { goto not_found; } ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "secure cookie set md5 base string: \"%V\"", &val); ngx_md5_init(&md5); ngx_md5_update(&md5, val.data, val.len); ngx_md5_final(md5_buf, &md5); res.len = 24; res.data = ngx_pcalloc(r->pool, res.len); if (res.data == NULL) { goto not_found; } val.len = 16; val.data = md5_buf; ngx_encode_base64(&res, &val); ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "secure cookie set md5 base64: \"%V\"", &res); v->len = res.len; v->valid = 1; v->no_cacheable = 0; v->not_found = 0; v->data = res.data; return NGX_OK; not_found: v->not_found = 1; return NGX_OK; }
static ngx_uint_t ngx_http_auth_mysql_check_md5(ngx_http_request_t *r, ngx_str_t sent_password, ngx_str_t actual_password) { u_char md5_str[2*MD5_DIGEST_LENGTH + 1]; u_char md5_digest[MD5_DIGEST_LENGTH]; ngx_md5_t md5; ngx_md5_init(&md5); ngx_md5_update(&md5, sent_password.data, sent_password.len); ngx_md5_final(md5_digest, &md5); ngx_hex_dump(md5_str, md5_digest, MD5_DIGEST_LENGTH); md5_str[2*MD5_DIGEST_LENGTH] = '\0'; return (ngx_strcmp(actual_password.data, md5_str) == 0)? NGX_OK : NGX_DECLINED; }
static void ngx_rtmp_notify_set_name(u_char *dst, size_t dst_len, u_char *src, size_t src_len) { u_char result[16], *p; ngx_md5_t md5; ngx_md5_init(&md5); ngx_md5_update(&md5, src, src_len); ngx_md5_final(result, &md5); p = ngx_hex_dump(dst, result, ngx_min((dst_len - 1) / 2, 16)); *p = '\0'; }
static ngx_int_t ngx_http_requestid_set_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) { ngx_md5_t md5; ngx_http_requestid_conf_t *conf; u_char *end; u_char val[NGX_INT64_LEN * 3 + 3]; u_char hashb[MD5_BHASH_LEN]; ngx_uint_t i, k; conf = ngx_http_get_module_loc_conf(r, ngx_http_requestid_module); if (conf->enable == 0) { v->not_found = 1; return NGX_OK; } end = ngx_sprintf(val, "%i,%ui,%i", ngx_pid, r->connection->number, ngx_random()); *end = 0; ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "requestid: data for hash=%s", val); ngx_md5_init(&md5); ngx_md5_update(&md5, val, end-val); ngx_md5_final(hashb, &md5); v->valid = 1; v->no_cacheable = 0; v->not_found = 0; v->len = MD5_HASH_LEN; v->data = ngx_pnalloc(r->pool, MD5_HASH_LEN); if (v->data == NULL) { return NGX_ERROR; } for (i = TIMESTAMP_LENGTH & ~1, k = 0; i < MD5_HASH_LEN; i += 2, ++k) { v->data[i] = hex[hashb[k] >> 4]; v->data[i+1] = hex[hashb[k] & 0xf]; } ngx_snprintf(v->data, TIMESTAMP_LENGTH, "%ui%03d", r->start_sec, r->start_msec); return NGX_OK; }
static void ngx_http_parallel_calculate_key( u_char* key, ngx_http_request_t *r) { ngx_md5_t md5; ngx_md5_init(&md5); if (r->headers_in.host != NULL) { ngx_md5_update(&md5, r->headers_in.host->value.data, r->headers_in.host->value.len); } ngx_md5_update(&md5, r->uri.data, r->uri.len); ngx_md5_final(key, &md5); }
void calc_req_digest( ngx_http_request_t* r, radius_str_t* secret, u_char* digest ) { ngx_md5_t md5; ngx_md5_init( &md5 ); ngx_md5_update( &md5, secret->s, secret->len ); ngx_md5_update( &md5, r->headers_in.user.data, r->headers_in.user.len ); ngx_md5_update( &md5, r->headers_in.passwd.data, r->headers_in.passwd.len ); u_char d[ 16 ]; ngx_md5_final( d, &md5 ); ngx_hex_dump( digest, d, sizeof( d ) ); }
static int ngx_http_static_etags_md5(unsigned int size, char *file, char *md5sum, ngx_log_t *log) { FILE *fp = NULL; char data[4096]; int ret; int j; int chunk_size = 4096; int chunks = 0; int left_over = 0; unsigned int fileLen; ngx_md5_t md5; unsigned char digest[16]; u_char hex[] = "0123456789abcdef"; ngx_md5_init(&md5); fp = fopen((char *) file, "rb"); if (fp == NULL) return (int ) 1; fseek(fp, 0, SEEK_END); fileLen = ftell(fp); fseek(fp, 0, SEEK_SET); ngx_md5_init(&md5); chunks = fileLen / chunk_size; left_over = fileLen % chunk_size; for (j = 0; j < chunks; j++) { ret = fread(&data, chunk_size, 1 ,fp); ngx_md5_update(&md5, data, chunk_size); } if(left_over) { ret = fread(&data, left_over, 1 ,fp); ngx_md5_update(&md5, data, left_over); } fclose(fp); ngx_md5_final(digest, &md5); ngx_memzero(md5sum, 33); md5sum[32] = '\0'; for ( j = 0 ; j < 16; j++ ) { md5sum[2*j] = hex[digest[j] >> 4]; md5sum[2*j+1] = hex[digest[j] & 0xf]; } return (int ) 0; }
ngx_int_t ngx_http_sticky_misc_md5(ngx_pool_t *pool, void *in, size_t len, ngx_str_t *digest) { ngx_md5_t md5; u_char hash[MD5_DIGEST_LENGTH]; digest->data = ngx_pcalloc(pool, MD5_DIGEST_LENGTH * 2); if (digest->data == NULL) { return NGX_ERROR; } digest->len = MD5_DIGEST_LENGTH * 2; ngx_md5_init(&md5); ngx_md5_update(&md5, in, len); ngx_md5_final(hash, &md5); ngx_hex_dump(digest->data, hash, MD5_DIGEST_LENGTH); return NGX_OK; }
static ngx_int_t ngx_http_vod_dash_webm_handle_init_segment( ngx_http_vod_submodule_context_t* submodule_context, ngx_str_t* response, ngx_str_t* content_type) { vod_status_t rc; ngx_md5_t md5; ngx_str_t* uri; uint64_t track_uid; u_char uri_key[16]; // calculate a uid for track based on the request uri uri = &submodule_context->r->uri; ngx_md5_init(&md5); ngx_md5_update(&md5, uri->data, uri->len); ngx_md5_final(uri_key, &md5); ngx_memcpy(&track_uid, uri_key, sizeof(track_uid)); rc = mkv_build_init_segment( &submodule_context->request_context, submodule_context->media_set.sequences[0].filtered_clips[0].first_track, track_uid, response); if (rc != VOD_OK) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, submodule_context->request_context.log, 0, "ngx_http_vod_dash_webm_handle_init_segment: mkv_build_init_segment failed %i", rc); return ngx_http_vod_status_to_ngx_error(rc); } if (submodule_context->media_set.track_count[MEDIA_TYPE_VIDEO] != 0) { content_type->data = webm_video_content_type; content_type->len = sizeof(webm_video_content_type) - 1; } else { content_type->data = webm_audio_content_type; content_type->len = sizeof(webm_audio_content_type) - 1; } return NGX_OK; }
static void sample_md5() { char key[] = "test_string"; ngx_md5_t md5; u_char digest[16]; int i; ngx_md5_init(&md5); ngx_md5_update(&md5, key, ngx_strlen(key)); ngx_md5_final(digest, &md5); puts("sample_md5 --------"); printf("string = [%s]\n", key); for (i = 0; i < sizeof(digest); i++) { printf("%02x", digest[i]); } printf("\n"); return; }
static ngx_int_t ngx_http_upstream_session_sticky_set_sid(ngx_conf_t *cf, ngx_http_ss_server_t *s) { u_char buf[16]; ngx_md5_t md5; s->sid.len = 32; s->sid.data = ngx_pnalloc(cf->pool, 32); if (s->sid.data == NULL) { return NGX_ERROR; } ngx_md5_init(&md5); ngx_md5_update(&md5, s->name->data, s->name->len); ngx_md5_final(buf, &md5); ngx_hex_dump(s->sid.data, buf, 16); return NGX_OK; }
static JSBool method_md5(JSContext *cx, JSObject *self, uintN argc, jsval *argv, jsval *rval) { JSString *jsstr; ngx_md5_t md5; u_char *str, hash[16], hex[32]; size_t len; TRACE(); if (argc != 1) { JS_ReportError(cx, "Nginx.md5 takes 1 argument"); return JS_FALSE; } jsstr = JS_ValueToString(cx, argv[0]); if (jsstr == NULL) { return JS_FALSE; } str = (u_char *) JS_GetStringBytes(jsstr); if (str == NULL) { return JS_FALSE; } len = ngx_strlen(str); ngx_md5_init(&md5); ngx_md5_update(&md5, str, len); ngx_md5_final(hash, &md5); ngx_hex_dump(hex, hash, 16); DATA_LEN_to_JS_STRING_to_JSVAL(cx, hex, 32, *rval); return JS_TRUE; }
int main (int argc, char *argv[]) { ngx_int_t i; ngx_md5_t md5; u_char *p, md5_buf[16], md5_dump_buf[32]; ngx_str_t s = ngx_string("bokko"); printf("%s:", s.data); ngx_md5_init(&md5); ngx_md5_update(&md5, s.data, s.len); ngx_md5_final(md5_buf, &md5); p = md5_dump_buf; p = ngx_hex_dump(p, md5_buf, 16); for (i=0;i<32;i++) { printf("%c", md5_dump_buf[i]); } printf("\n"); return 0; }
static ngx_int_t ngx_http_cp_gen_cookie_data(ngx_http_request_t *r, ngx_str_t *cookie, ngx_str_t *neteye_cookie, ngx_uint_t magic) { ngx_md5_t md5_ctx; u_char md5_digest[16]; u_char *hex_output, *source; ngx_uint_t di; source = ngx_pcalloc(r->pool, cookie->len + sizeof(magic)); if (!source) { return NGX_ERROR; } hex_output = ngx_pcalloc(r->pool, NGX_HTTP_CP_MD5_LEN + 1); if (!hex_output) { return NGX_ERROR; } memcpy(source, cookie->data, cookie->len); memcpy(source + cookie->len, &magic, sizeof(magic)); ngx_md5_init(&md5_ctx); ngx_md5_update(&md5_ctx, (void *)source, strlen((char *)source)); ngx_md5_final(md5_digest, &md5_ctx); for (di = 0; di < 16; di++) { sprintf((char *)hex_output + di * 2, "%02x", md5_digest[di]); } neteye_cookie->data = hex_output; neteye_cookie->len = NGX_HTTP_CP_MD5_LEN; return NGX_OK; }
static ngx_int_t ngx_secure_token_cht_get_var( ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) { ngx_secure_token_cht_token_t* token = (void*)data; ngx_str_t expires_str; ngx_str_t md5hash_str; ngx_str_t token_str; ngx_str_t acl; ngx_md5_t md5; u_char end_time_buf[NGX_INT32_LEN]; u_char md5hash_buf[MD5_DIGEST_LENGTH]; u_char token_buf[ngx_base64_encoded_length(MD5_DIGEST_LENGTH)]; time_t end_time; size_t result_size; u_char* p; ngx_int_t rc; // get the acl rc = ngx_http_secure_token_get_acl(r, token->acl, &acl); if (rc != NGX_OK) { return rc; } // get the end time end_time = token->end.val; if (token->end.type == NGX_HTTP_SECURE_TOKEN_TIME_RELATIVE) { end_time += ngx_time(); } expires_str.data = end_time_buf; expires_str.len = ngx_sprintf(end_time_buf, "%uD", (uint32_t)end_time) - end_time_buf; // calculate the signature ngx_md5_init(&md5); ngx_md5_update(&md5, acl.data, acl.len); ngx_md5_update(&md5, token->key.data, token->key.len); ngx_md5_update(&md5, expires_str.data, expires_str.len); ngx_md5_final(md5hash_buf, &md5); md5hash_str.data = md5hash_buf; md5hash_str.len = sizeof(md5hash_buf); token_str.data = token_buf; ngx_encode_base64url(&token_str, &md5hash_str); // get the result size result_size = sizeof(TOKEN_PART1) + token_str.len + sizeof(TOKEN_PART2) + expires_str.len; // allocate the result p = ngx_pnalloc(r->pool, result_size); if (p == NULL) { return NGX_ERROR; } v->data = p; // build the result p = ngx_copy(p, TOKEN_PART1, sizeof(TOKEN_PART1) - 1); p = ngx_copy(p, token_str.data, token_str.len); p = ngx_copy(p, TOKEN_PART2, sizeof(TOKEN_PART2) - 1); p = ngx_copy(p, expires_str.data, expires_str.len); *p = '\0'; v->len = p - v->data; v->valid = 1; v->no_cacheable = 0; v->not_found = 0; return NGX_OK; }
static ngx_int_t ngx_http_upstream_init_q_chash(ngx_conf_t *cf, ngx_http_upstream_srv_conf_t *us) { unsigned char hash_data[HASH_DATA_LENGTH] = {}; ngx_http_upstream_q_chash_ring *q_chash_ring; ngx_http_upstream_q_chash_srv_conf_t *uchscf; ngx_http_upstream_rr_peers_t *peers; ngx_uint_t vnode_num, i, j, k, fill_next; ngx_int_t si; uint32_t point; uchscf = ngx_http_conf_upstream_srv_conf(us, ngx_http_upstream_q_chash_module); if (uchscf == NULL) { return NGX_ERROR; } q_chash_ring = ngx_pcalloc(cf->pool, sizeof(*q_chash_ring)); if(q_chash_ring == NULL) return NGX_ERROR; if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) { return NGX_ERROR; } us->peer.init = ngx_http_upstream_init_q_chash_peer; uchscf->q_chash_ring = q_chash_ring; peers = us->peer.data; for(i = 0; i < peers->number; i++) { if(!peers->peer[i].down) q_chash_ring->nr_valid_peers ++; } // old_cycle's log_level is NGX_LOG_NOTICE //ngx_log_debug(NGX_LOG_DEBUG_HTTP, cf->log, 0, "upstream %V nr_valid_peers %ui", peers->name, q_chash_ring->nr_valid_peers); // no need to hash if(q_chash_ring->nr_valid_peers <= 1) { return NGX_OK; } // create vnodes, peer_index field, sort q_chash_ring->vnodes = ngx_palloc(cf->pool, sizeof(q_chash_vnode_t) * peers->total_weight * NR_VNODE); if(q_chash_ring->vnodes == NULL) { return NGX_ERROR; } for(i = 0; i < peers->number; i++) { if(peers->peer[i].down) { continue; } vnode_num = peers->peer[i].weight * NR_VNODE; for(j = 0; j < vnode_num / 4; j++) { ngx_snprintf(hash_data, HASH_DATA_LENGTH, "%V-%ui%Z", &peers->peer[i].name, j); u_char md5[16]; ngx_md5_t ctx; ngx_md5_init(&ctx); ngx_md5_update(&ctx, hash_data, ngx_strlen(hash_data)); ngx_md5_final(md5, &ctx); for(k = 0; k < 4; k++) { point = *(uint32_t *)&md5[k * 4]; q_chash_ring->vnodes[q_chash_ring->nr_vnodes].peer_index = i; q_chash_ring->vnodes[q_chash_ring->nr_vnodes].point = point; q_chash_ring->nr_vnodes ++; } } } // old_cycle's log_level is NGX_LOG_NOTICE //ngx_log_debug(NGX_LOG_DEBUG_HTTP, cf->log, 0, "upstream %V nr_vnodes %ui", peers->name, q_chash_ring->nr_vnodes); ngx_qsort(q_chash_ring->vnodes, q_chash_ring->nr_vnodes, sizeof(q_chash_vnode_t), (const void *)compare_vnodes_point); // fill vnode's next field for(i = 1; ; i ++) { if(q_chash_ring->vnodes[0].peer_index == q_chash_ring->vnodes[i].peer_index) continue; q_chash_ring->vnodes[0].next = i; break; } fill_next = 0; for(si = q_chash_ring->nr_vnodes - 1; si >= 0; si--) { if(q_chash_ring->vnodes[si].peer_index == q_chash_ring->vnodes[fill_next].peer_index) { q_chash_ring->vnodes[si].next = q_chash_ring->vnodes[fill_next].next; } else { q_chash_ring->vnodes[si].next = fill_next; fill_next = si; } } // old_cycle's log_level is NGX_LOG_NOTICE /* for(i = 0; i < q_chash_ring->nr_vnodes; i++) { ngx_log_debug(NGX_LOG_DEBUG_HTTP, cf->log, 0, "%ui, next %ui peer_index %ui point %uD", i, q_chash_ring->vnodes[i].next, q_chash_ring->vnodes[i].peer_index, q_chash_ring->vnodes[i].point); } */ // calculate peer ratio for debug ~ ngx_uint_t *statistic_array = ngx_pcalloc(cf->pool, sizeof(uint32_t) * peers->number); if(statistic_array == NULL) return NGX_OK; uint32_t before_point = 0; for(i = 1; i < q_chash_ring->nr_vnodes; i++) { statistic_array[q_chash_ring->vnodes[i].peer_index] += q_chash_ring->vnodes[i].point - before_point; before_point = q_chash_ring->vnodes[i].point; } statistic_array[q_chash_ring->vnodes[0].peer_index] += 0xFFFFFFFF - before_point; for(i = 0; i < peers->number; i++) { if(peers->peer[i].down) continue; ngx_log_error(NGX_LOG_NOTICE, cf->log, 0, "upstream %V %V weight %ui actually ratio %.2f%%", peers->name, &peers->peer[i].name, peers->peer[i].weight, 100 * (double)statistic_array[i] / 0xFFFFFFFF); } ngx_pfree(cf->pool, statistic_array); return NGX_OK; }
static ngx_int_t ngx_http_wd_handler(ngx_http_request_t *r) { ngx_http_wd_loc_conf_t *wdlcf; ngx_str_t file_path; u_char *p, *n; u_char *hash_value; u_char buf[1024] = {}; u_char md5_digest[16]; ngx_md5_t md5; int fd, uri_len; ngx_uint_t key; ssize_t rlen; ngx_http_wd_ctx_t *ctx; ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "web defacement handler begin"); wdlcf = ngx_http_get_module_loc_conf(r, ngx_http_web_defacement_module); if (!wdlcf->enabled || wdlcf->file_name_hash.buckets == NULL) { return NGX_DECLINED; } #if (NGX_HTTP_NETEYE_SECURITY) ctx = ngx_http_ns_get_module_ctx(r, ngx_http_web_defacement_module); if (ctx == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } #else ctx = ngx_http_get_module_ctx(r, ngx_http_web_defacement_module); ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "web defacement module: r=%p, ctx=%p, uri=%p", r, ctx, &r->uri); if(ctx == NULL) { ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_wd_ctx_t)); if (ctx == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } ngx_http_set_ctx(r, ctx, ngx_http_web_defacement_module); } #endif uri_len = r->uri.len; // Get dir if (r->uri.data[r->uri.len - 1] == '/') { uri_len += wdlcf->index_file.len; } n = ngx_pnalloc(r->pool, wdlcf->orig_path.len + uri_len + 1); if (n == NULL) { return NGX_ERROR; } p = ngx_cpymem(n, wdlcf->orig_path.data, wdlcf->orig_path.len); if (r->uri.data[r->uri.len - 1] == '/' && wdlcf->index_file.len > 0) { p = ngx_cpymem(p, r->uri.data, r->uri.len); ngx_cpystrn(p, wdlcf->index_file.data, wdlcf->index_file.len + 1); } else { ngx_cpystrn(p, r->uri.data, r->uri.len + 1); } file_path.len = wdlcf->orig_path.len + uri_len; file_path.data = n; key = ngx_hash_key_lc(file_path.data, file_path.len); hash_value = ngx_hash_find(&wdlcf->file_name_hash, key, file_path.data, file_path.len); if (hash_value == NULL) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "In hash, can't find file %V, pass", &file_path); return NGX_DECLINED; } else { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "Find file %s", (char *)file_path.data); } fd = open((const char *)file_path.data, O_RDONLY); if (fd < 0) { ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "Can't open file: %V", &file_path); do_action: ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "The uri is defaced, set variables"); ctx->defaced = 1; ctx->file.data = r->uri.data; ctx->file.len = r->uri.len; if (wdlcf->log_enabled) { ngx_http_wd_write_attack_log(r); } return NGX_DECLINED; } ngx_md5_init(&md5); while (1) { rlen = read(fd, buf, sizeof(buf)); if (rlen < 0) { close(fd); goto do_action; } if (rlen == 0) { break; } ngx_md5_update(&md5, (void *)buf, rlen); } close(fd); ngx_md5_final(md5_digest, &md5); if (memcmp(hash_value, md5_digest, sizeof(md5_digest)) != 0) { goto do_action; } return NGX_DECLINED; }
static ngx_int_t ngx_http_dynamic_etags_body_filter(ngx_http_request_t *r, ngx_chain_t *in) { ngx_chain_t *chain_link; ngx_http_dynamic_etags_module_ctx_t *ctx; ngx_int_t rc; ngx_md5_t md5; unsigned char digest[16]; ngx_uint_t i; ctx = ngx_http_get_module_ctx(r, ngx_http_dynamic_etags_module); if (ctx == NULL) { return ngx_http_next_body_filter(r, in); } ngx_http_dynamic_etags_loc_conf_t *loc_conf; loc_conf = ngx_http_get_module_loc_conf(r, ngx_http_dynamic_etags_module); if (1 == loc_conf->enable) { ngx_md5_init(&md5); for (chain_link = in; chain_link; chain_link = chain_link->next) { ngx_md5_update(&md5, chain_link->buf->pos, chain_link->buf->last - chain_link->buf->pos); } ngx_md5_final(digest, &md5); unsigned char* etag = ngx_pcalloc(r->pool, 34); etag[0] = etag[33] = '"'; for ( i = 0 ; i < 16; i++ ) { etag[2*i+1] = hex[digest[i] >> 4]; etag[2*i+2] = hex[digest[i] & 0xf]; } if(!r->headers_out.etag) { r->headers_out.etag = ngx_list_push(&r->headers_out.headers); } r->headers_out.etag->hash = 1; r->headers_out.etag->key.len = sizeof("ETag") - 1; r->headers_out.etag->key.data = (u_char *) "ETag"; r->headers_out.etag->value.len = 34; r->headers_out.etag->value.data = etag; /* look for If-None-Match in request headers */ ngx_uint_t found=0; ngx_list_part_t *part = NULL; ngx_table_elt_t *header = NULL; ngx_table_elt_t if_none_match; part = &r->headers_in.headers.part; header = part->elts; for ( i = 0 ; ; i++ ) { if ( i >= part->nelts) { if ( part->next == NULL ) { break; } part = part->next; header = part->elts; i = 0; } if ( ngx_strcmp(header[i].key.data, "If-None-Match") == 0 ) { if_none_match = header[i]; found = 1; break; } } if ( found ) { if ( ngx_strncmp(r->headers_out.etag->value.data, if_none_match.value.data, r->headers_out.etag->value.len) == 0 ) { r->headers_out.status = NGX_HTTP_NOT_MODIFIED; r->headers_out.status_line.len = 0; r->headers_out.content_type.len = 0; ngx_http_clear_content_length(r); ngx_http_clear_accept_ranges(r); } } }