idx int64 | project string | commit_id string | project_url string | commit_url string | commit_message string | target int64 | func string | func_hash float64 | file_name string | file_hash float64 | cwe list | cve string | cve_desc string | nvd_url string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
516,008 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void threadcache_free(nedpool *RESTRICT p, threadcache *RESTRICT tc, int mymspace, void *RESTRICT mem, size_t size, int isforeign) THROWSPEC
{
unsigned int bestsize;
unsigned int idx=size2binidx(size);
threadcacheblk *RESTRICT *RESTRICT binsptr, *RESTRICT tck=(threadcacheblk *RESTRICT) mem;
assert(size>... | 53,550,884,949,984,250,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,009 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR size_t nedblksize(int *RESTRICT isforeign, void *RESTRICT mem, unsigned flags) THROWSPEC
{
if(mem)
{
if(isforeign) *isforeign=1;
#if USE_MAGIC_HEADERS
{
size_t *_mem=(size_t *) mem-3;
if(_mem[0]==*(size_t *) "NEDMALOC")
{
mstate mspace=(mstate) _mem[1];
size_t size... | 146,572,289,845,649,040,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,010 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NOINLINE threadcache *AllocCache(nedpool *RESTRICT p) THROWSPEC
{
threadcache *tc=0;
int n, end;
#if USE_LOCKS
ACQUIRE_LOCK(&p->mutex);
#endif
for(n=0; n<THREADCACHEMAXCACHES && p->caches[n]; n++);
if(THREADCACHEMAXCACHES==n)
{ /* List exhausted, so disable for this thread */
#if USE_LOCKS
REL... | 83,065,593,991,571,570,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,011 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedpindependent_comalloc(nedpool *p, size_t elems, size_t *sizes, void **chunks) THROWSPEC
{
void **ret;
threadcache *tc;
int mymspace;
size_t i, *adjustedsizes=(size_t *) alloca(elems*sizeof(size_t));
if(!adjustedsizes) return 0;
for(i=0; i<elems; i++)... | 284,538,891,087,088,600,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,012 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR struct nedmallinfo nedmallinfo(void) THROWSPEC { return nedpmallinfo((nedpool *) 0); }
| 221,360,412,003,003,670,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,013 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR int nedmalloc_trim(size_t pad) THROWSPEC { return nedpmalloc_trim((nedpool *) 0, pad); }
| 53,914,718,684,304,445,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,014 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedrealloc(void *mem, size_t size) THROWSPEC { return nedprealloc((nedpool *) 0, mem, size); }
| 160,049,941,772,078,340,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,015 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | void neddestroypool(nedpool *p) THROWSPEC
{
unsigned int n;
#if USE_LOCKS
ACQUIRE_LOCK(&p->mutex);
#endif
DestroyCaches(p);
for(n=0; p->m[n]; n++)
{
#if USE_ALLOCATOR==1
destroy_mspace(p->m[n]);
#endif
p->m[n]=0;
}
#if USE_LOCKS
RELEASE_LOCK(&p->mutex);
DESTROY_LOCK(&p->mutex);
#endif
if(... | 122,679,107,385,170,580,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,016 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void DestroyCaches(nedpool *RESTRICT p) THROWSPEC
{
if(p->caches)
{
threadcache *tc;
int n;
nedflushlogs(p, 0);
for(n=0; n<THREADCACHEMAXCACHES; n++)
{
if((tc=p->caches[n]))
{
tc->mymspace=-1;
tc->threadid=0;
CallFree(0, tc, 0);
p->caches[n]=0;
}
}
}
}
| 20,218,960,415,507,565,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,017 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NOINLINE void ReleaseFreeInCache(nedpool *RESTRICT p, threadcache *RESTRICT tc, int mymspace) THROWSPEC
{
unsigned int age=THREADCACHEMAXFREESPACE/8192;
#if USE_LOCKS
/*ACQUIRE_LOCK(&p->m[mymspace]->mutex);*/
#endif
while(age && tc->freeInCache>=THREADCACHEMAXFREESPACE)
{
RemoveCacheEntries(p, tc, ... | 222,100,733,187,682,100,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,018 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedrealloc2(void *mem, size_t size, size_t alignment, unsigned flags) THROWSPEC { return nedprealloc2((nedpool *) 0, mem, size, alignment, flags); }
| 138,990,860,223,771,940,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,019 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpmalloc(nedpool *p, size_t size) THROWSPEC
{
unsigned flags=NEDMALLOC_FORCERESERVE(p, 0, size);
return nedpmalloc2(p, size, 0, flags);
}
| 18,285,440,970,008,720,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,020 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR size_t nedmalloc_footprint() THROWSPEC { return nedpmalloc_footprint((nedpool *) 0); }
| 2,372,287,367,408,179,200,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,021 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedprealloc(nedpool *p, void *mem, size_t size) THROWSPEC
{
unsigned flags=NEDMALLOC_FORCERESERVE(p, mem, size);
#if ENABLE_USERMODEPAGEALLOCATOR
/* If the user mode page allocator is turned on in a 32 bit process,
don't automatically reserve eight times the address ... | 177,597,998,964,642,500,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,022 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void tcsanitycheck(threadcacheblk *RESTRICT *RESTRICT ptr) THROWSPEC
{
assert((ptr[0] && ptr[1]) || (!ptr[0] && !ptr[1]));
if(ptr[0] && ptr[1])
{
assert(ptr[0]->isforeign || nedblkmstate(ptr[0]));
assert(ptr[1]->isforeign || nedblkmstate(ptr[1]));
assert(nedblksize(0, ptr[0], 0)>=sizeof(threadcac... | 120,599,951,556,609,470,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,023 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | struct nedmallinfo nedpmallinfo(nedpool *p) THROWSPEC
{
int n;
struct nedmallinfo ret={0};
if(!p) { p=&syspool; if(!syspool.threads) InitPool(&syspool, 0, -1); }
for(n=0; p->m[n]; n++)
{
#if USE_ALLOCATOR==1 && !NO_MALLINFO
struct mallinfo t=mspace_mallinfo(p->m[n]);
ret.arena+=t.arena;
ret.ordblks... | 315,530,798,199,321,300,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,024 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | void nedmalloc_stats() THROWSPEC { nedpmalloc_stats((nedpool *) 0); }
| 95,276,947,294,648,850,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,025 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void *threadcache_malloc(nedpool *RESTRICT p, threadcache *RESTRICT tc, size_t *RESTRICT _size) THROWSPEC
{
void *RESTRICT ret=0;
size_t size=*_size, blksize=0;
unsigned int bestsize;
unsigned int idx=size2binidx(size);
threadcacheblk *RESTRICT blk, *RESTRICT *RESTRICT binsptr;
#ifdef FULLSANITYCHECK... | 198,427,651,348,898,540,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,026 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static timeCount GetTimestamp()
{
static timeCount baseCount;
timeCount ret;
#ifdef CLOCK_MONOTONIC
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
ret=((timeCount) ts.tv_sec*1000000000000LL)+ts.tv_nsec*1000LL;
#else
struct timeval tv;
gettimeofday(&tv, 0);
ret=((timeCount) tv.tv_sec*1000000... | 261,302,553,718,051,400,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,027 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | void nedpsetvalue(nedpool *p, void *v) THROWSPEC
{
if(!p) { p=&syspool; if(!syspool.threads) InitPool(&syspool, 0, -1); }
p->uservalue=v;
}
| 7,740,137,145,184,396,000,000,000,000,000,000,000 | nedmalloc.c | 297,977,836,029,106,800,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,028 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NOINLINE mstate FindMSpace(nedpool *RESTRICT p, threadcache *RESTRICT tc, int *RESTRICT lastUsed, size_t size) THROWSPEC
{ /* Gets called when thread's last used mspace is in use. The strategy
is to run through the list of all available mspaces looking for an
unlocked one and if we fail, we create a new one... | 205,847,803,349,005,480,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,029 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR nedpool *nedcreatepool(size_t capacity, int threads) THROWSPEC
{
nedpool *ret=0;
if(!poollist)
{
PoolList *newpoollist=0;
if(!(newpoollist=(PoolList *) nedpcalloc(0, 1, sizeof(PoolList)+sizeof(nedpool *)))) return 0;
#if USE_LOCKS
INITIAL_LOCK(&poollistlock);
AC... | 153,803,908,615,083,900,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,030 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static FORCEINLINE void GetThreadCache(nedpool *RESTRICT *RESTRICT p, threadcache *RESTRICT *RESTRICT tc, int *RESTRICT mymspace, size_t *RESTRICT size) THROWSPEC
{
int mycache;
#if THREADCACHEMAX
if(size && *size<sizeof(threadcacheblk)) *size=sizeof(threadcacheblk);
#endif
if(!*p)
GetThreadCache_cold1(p);
... | 75,662,377,250,746,500,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,031 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpmalloc2(nedpool *p, size_t size, size_t alignment, unsigned flags) THROWSPEC
{
void *ret=0;
threadcache *tc;
int mymspace;
GetThreadCache(&p, &tc, &mymspace, &size);
#if THREADCACHEMAX
if(alignment<=MALLOC_ALIGNMENT && !(flags & NM_FLAGS_MASK) && tc && size<=... | 11,162,199,105,753,300,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,032 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpmemalign(nedpool *p, size_t alignment, size_t bytes) THROWSPEC
{
unsigned flags=NEDMALLOC_FORCERESERVE(p, 0, bytes);
return nedpmalloc2(p, bytes, alignment, flags);
}
| 242,654,785,714,368,870,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,033 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static timeCount GetTimestamp()
{
static LARGE_INTEGER ticksPerSec;
static double scalefactor;
static timeCount baseCount;
LARGE_INTEGER val;
timeCount ret;
if(!scalefactor)
{
if(QueryPerformanceFrequency(&ticksPerSec))
scalefactor=ticksPerSec.QuadPart/1000000000000.0;
else
scalefactor=1;
... | 142,111,739,480,418,270,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,034 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static FORCEINLINE NEDMALLOCNOALIASATTR unsigned int size2binidx(size_t _size) THROWSPEC
{ /* 8=1000 16=10000 20=10100 24=11000 32=100000 48=110000 4096=1000000000000 */
unsigned int topbit, size=(unsigned int)(_size>>4);
/* 16=1 20=1 24=1 32=10 48=11 64=100 96=110 128=1000 4096=100000000 */
#if defined(__GNUC... | 13,414,292,865,312,382,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,035 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | void neddisablethreadcache(nedpool *p) THROWSPEC
{
nedtrimthreadcache(p, 1);
}
| 126,767,851,506,641,200,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,036 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | void neddestroysyspool() THROWSPEC
{
nedpool *p=&syspool;
int n;
#if USE_LOCKS
ACQUIRE_LOCK(&p->mutex);
#endif
DestroyCaches(p);
for(n=0; p->m[n]; n++)
{
#if USE_ALLOCATOR==1
destroy_mspace(p->m[n]);
#endif
p->m[n]=0;
}
/* Render syspool unusable */
for(n=0; n<THREADCACHEMAXCACHES; n++)
... | 35,532,824,276,731,123,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,037 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR void nedfree2(void *mem, unsigned flags) THROWSPEC { nedpfree2((nedpool *) 0, mem, flags); }
| 232,996,138,002,992,260,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,038 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NOINLINE int InitPool(nedpool *RESTRICT p, size_t capacity, int threads) THROWSPEC
{ /* threads is -1 for system pool */
ensure_initialization();
ACQUIRE_MALLOC_GLOBAL_LOCK();
if(p->threads) goto done;
#if USE_LOCKS
if(INITIAL_LOCK(&p->mutex)) goto err;
#endif
if(TLSALLOC(&p->mycache)) goto err;
#i... | 101,043,854,881,309,820,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,039 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | void nedpmalloc_stats(nedpool *p) THROWSPEC
{
int n;
if(!p) { p=&syspool; if(!syspool.threads) InitPool(&syspool, 0, -1); }
for(n=0; p->m[n]; n++)
{
#if USE_ALLOCATOR==1
mspace_malloc_stats(p->m[n]);
#endif
}
}
| 87,432,435,524,646,700,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,040 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void DoStackWalk(logentry *p) THROWSPEC
{
void *backtr[NEDMALLOC_STACKBACKTRACEDEPTH];
size_t size;
char **strings;
size_t i2;
size=backtrace(backtr, NEDMALLOC_STACKBACKTRACEDEPTH);
strings=backtrace_symbols(backtr, size);
for(i2=0; i2<size; i2++)
{ // Format can be <file path>(<mangled symbol>+... | 291,891,504,856,747,520,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,041 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | void nedtrimthreadcache(nedpool *p, int disable) THROWSPEC
{
int mycache;
if(!p)
{
p=&syspool;
if(!syspool.threads) InitPool(&syspool, 0, -1);
}
mycache=(int)(size_t) TLSGET(p->mycache);
if(!mycache)
{ /* Set to mspace 0 */
if(disable && TLSSET(p->mycache, (void *)(size_t)-1)) abort();
}
els... | 224,137,067,311,146,750,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,042 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR void nedfree(void *mem) THROWSPEC { nedpfree((nedpool *) 0, mem); }
| 108,879,783,957,724,320,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,043 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static FORCEINLINE NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void *CallMalloc(void *RESTRICT mspace, size_t size, size_t alignment, unsigned flags) THROWSPEC
{
void *RESTRICT ret=0;
#if USE_MAGIC_HEADERS
size_t _alignment=alignment;
size_t *_ret=0;
size+=alignment+3*sizeof(size_t);
_alignment=0;
#endif
#if US... | 240,310,019,262,433,470,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,044 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedpcalloc(nedpool *p, size_t no, size_t size) THROWSPEC
{
size_t bytes=no*size;
/* Avoid multiplication overflow. */
if(size && no!=bytes/size)
return 0;
unsigned flags=NEDMALLOC_FORCERESERVE(p, 0, bytes);
return nedpmalloc2(p, bytes, 0, M2_ZERO_MEMORY|flags);... | 13,836,876,005,777,182,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,045 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_comalloc(size_t elems, size_t *sizes, void **chunks) THROWSPEC { return nedpindependent_comalloc((nedpool *) 0, elems, sizes, chunks); }
| 62,718,597,776,034,770,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,046 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR void* nedmalloc_internals(size_t *granularity, size_t *magic) THROWSPEC
{
#if USE_ALLOCATOR==1
if(granularity) *granularity=mparams.granularity;
if(magic) *magic=mparams.magic;
return (void *) &syspool;
#else
if(granularity) *granularity=0;
if(magic) *magic=0;
return 0;
#endif
}
| 267,323,454,469,977,200,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,047 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | size_t nedpmalloc_footprint(nedpool *p) THROWSPEC
{
size_t ret=0;
int n;
if(!p) { p=&syspool; if(!syspool.threads) InitPool(&syspool, 0, -1); }
for(n=0; p->m[n]; n++)
{
#if USE_ALLOCATOR==1
ret+=mspace_footprint(p->m[n]);
#endif
}
return ret;
}
| 276,529,886,072,563,160,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,048 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedpindependent_calloc(nedpool *p, size_t elemsno, size_t elemsize, void **chunks) THROWSPEC
{
void **ret;
threadcache *tc;
int mymspace;
GetThreadCache(&p, &tc, &mymspace, &elemsize);
#if USE_ALLOCATOR==0
GETMSPACE(m, p, tc, mymspace, elemsno*elemsize,
... | 278,425,985,848,171,250,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,049 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static DWORD64 __stdcall GetModBase(HANDLE hProcess, DWORD64 dwAddr) THROWSPEC
{
DWORD64 modulebase;
// Try to get the module base if already loaded, otherwise load the module
modulebase=SymGetModuleBase64(hProcess, dwAddr);
if(modulebase)
return modulebase;
else
{
MEMORY_BASIC_INFORMATION stMBI ;
... | 190,507,286,334,571,800,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,050 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static FORCEINLINE void CallFree(void *RESTRICT mspace, void *RESTRICT mem, int isforeign) THROWSPEC
{
#if USE_MAGIC_HEADERS
mstate oldmspace=0;
size_t *_mem=(size_t *) mem-3, oldsize=0;
#endif
if(isforeign)
{
#if USE_MAGIC_HEADERS
assert(_mem[0]!=*(size_t *) "NEDMALOC");
#endif
#if defined(DEBUG)
p... | 299,360,184,688,731,800,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,051 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR void nedpfree(nedpool *p, void *mem) THROWSPEC
{
nedpfree2(p, mem, 0);
}
| 133,919,993,691,234,610,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,052 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NEDMALLOCNOALIASATTR mstate nedblkmstate(void *RESTRICT mem) THROWSPEC
{
if(mem)
{
#if USE_MAGIC_HEADERS
size_t *_mem=(size_t *) mem-3;
if(_mem[0]==*(size_t *) "NEDMALOC")
{
return (mstate) _mem[1];
}
else return 0;
#else
#if USE_ALLOCATOR==0
/* Fail everything */
return 0;
#eli... | 146,293,398,439,999,700,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,053 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmalloc2(size_t size, size_t alignment, unsigned flags) THROWSPEC { return nedpmalloc2((nedpool *) 0, size, alignment, flags); }
| 296,676,449,527,482,400,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,054 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | int nedpmallopt(nedpool *p, int parno, int value) THROWSPEC
{
#if USE_ALLOCATOR==1
return mspace_mallopt(parno, value);
#else
return 0;
#endif
}
| 146,422,589,570,757,630,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,055 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | size_t nedflushlogs(nedpool *p, char *filepath) THROWSPEC
{
size_t count=0;
if(!p)
{
p=&syspool;
if(!syspool.threads) InitPool(&syspool, 0, -1);
}
if(p->caches)
{
threadcache *tc;
int n;
#if ENABLE_LOGGING
int haslogentries=0;
#endif
for(n=0; n<THREADCACHEMAXCACHES; n++)
{
if((tc... | 319,560,553,022,546,800,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,056 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void tcfullsanitycheck(threadcache *tc) THROWSPEC
{
threadcacheblk *RESTRICT *RESTRICT tcbptr=tc->bins;
int n;
for(n=0; n<=THREADCACHEMAXBINS; n++, tcbptr+=2)
{
threadcacheblk *RESTRICT b, *RESTRICT ob=0;
tcsanitycheck(tcbptr);
for(b=tcbptr[0]; b; ob=b, b=b->next)
{
assert(b->isforeign |... | 30,275,372,617,949,300,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,057 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static FORCEINLINE NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void *CallRealloc(void *RESTRICT mspace, void *RESTRICT mem, int isforeign, size_t oldsize, size_t newsize, size_t alignment, unsigned flags) THROWSPEC
{
void *RESTRICT ret=0;
#if USE_MAGIC_HEADERS
mstate oldmspace=0;
size_t *_ret=0, *_mem=(size_t *) mem-... | 311,586,522,952,342,120,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,058 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static FORCEINLINE logentry *LogOperation(threadcache *tc, nedpool *np, LogEntryType type, int mspace, size_t size, void *mem, size_t alignment, unsigned flags, void *returned) THROWSPEC
{
#if ENABLE_LOGGING
if(tc->logentries && NEDMALLOC_TESTLOGENTRY(tc, np, type, mspace, size, mem, alignment, flags, returned))
... | 282,657,336,734,507,400,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,059 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR size_t nedmemsize(void *RESTRICT mem) THROWSPEC { return nedblksize(0, mem, 0); }
| 261,051,505,002,439,900,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,060 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NOINLINE void GetThreadCache_cold1(nedpool *RESTRICT *RESTRICT p) THROWSPEC
{
*p=&syspool;
if(!syspool.threads) InitPool(&syspool, 0, -1);
}
| 106,578,689,905,114,630,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,061 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | nedpool **nedpoollist() THROWSPEC
{
nedpool **ret=0;
if(poollist)
{
#if USE_LOCKS
ACQUIRE_LOCK(&poollistlock);
#endif
if(!(ret=(nedpool **) nedmalloc((poollist->length+1)*sizeof(nedpool *)))) goto badexit;
memcpy(ret, poollist->list, (poollist->length+1)*sizeof(nedpool *));
badexit:
{
#if USE_LOC... | 147,167,205,056,405,740,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,062 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void *unsupported_operation(const char *opname) THROWSPEC
{
fprintf(stderr, "nedmalloc: The operation %s is not supported under this build configuration\n", opname);
abort();
return 0;
}
| 271,839,822,893,777,020,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,063 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR void nedpfree2(nedpool *p, void *mem, unsigned flags) THROWSPEC
{ /* Frees always happen in the mspace they happened in, so skip
locking the preferred mspace for this thread */
threadcache *tc;
int mymspace, isforeign=1;
size_t memsize;
if(!mem)
{ /* If you tried this on FreeBSD you'... | 120,580,952,184,345,230,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,064 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NOINLINE void RemoveCacheEntries(nedpool *RESTRICT p, threadcache *RESTRICT tc, unsigned int age) THROWSPEC
{
#ifdef FULLSANITYCHECKS
tcfullsanitycheck(tc);
#endif
if(tc->freeInCache)
{
threadcacheblk *RESTRICT *RESTRICT tcbptr=tc->bins;
int n;
for(n=0; n<=THREADCACHEMAXBINS; n++, tcbptr+=2)
... | 287,660,772,888,129,660,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,065 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmemalign(size_t alignment, size_t bytes) THROWSPEC { return nedpmemalign((nedpool *) 0, alignment, bytes); }
| 252,394,338,297,464,050,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,066 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static LPVOID ChkedTlsGetValue(DWORD idx)
{
LPVOID ret=TlsGetValue(idx);
assert(S_OK==GetLastError());
return ret;
}
| 163,785,433,407,430,260,000,000,000,000,000,000,000 | nedmalloc.c | 297,977,836,029,106,800,000,000,000,000,000,000,000 | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,067 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR void nedsetvalue(void *v) THROWSPEC { nedpsetvalue((nedpool *) 0, v); }
| 191,445,028,077,487,650,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,068 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedcalloc(size_t no, size_t size) THROWSPEC { return nedpcalloc((nedpool *) 0, no, size); }
| 122,353,701,421,175,650,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,069 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR int nedmallopt(int parno, int value) THROWSPEC { return nedpmallopt((nedpool *) 0, parno, value); }
| 190,863,241,158,365,500,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,070 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_calloc(size_t elemsno, size_t elemsize, void **chunks) THROWSPEC { return nedpindependent_calloc((nedpool *) 0, elemsno, elemsize, chunks); }
| 186,048,005,397,054,830,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,071 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static int ExceptionFilter(unsigned int code, struct _EXCEPTION_POINTERS *ep, CONTEXT *ct) THROWSPEC
{
*ct=*ep->ContextRecord;
return EXCEPTION_EXECUTE_HANDLER;
}
| 228,024,860,426,204,940,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,072 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static void DoStackWalk(logentry *p) THROWSPEC
{
int i,i2;
HANDLE mythread=(HANDLE) GetCurrentThread();
STACKFRAME64 sf={ 0 };
CONTEXT ct={ 0 };
if(!sym_myprocess)
{
DWORD symopts;
DuplicateHandle(GetCurrentProcess(), GetCurrentProcess(), GetCurrentProcess(), &sym_myprocess, 0, FALSE, DUPLICATE_SAME_... | 335,829,764,260,761,200,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,073 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static NOINLINE void GetThreadCache_cold2(nedpool *RESTRICT *RESTRICT p, threadcache *RESTRICT *RESTRICT tc, int *RESTRICT mymspace, int mycache) THROWSPEC
{
if(!mycache)
{ /* Need to allocate a new cache */
*tc=AllocCache(*p);
if(!*tc)
{ /* Disable */
if(TLSSET((*p)->mycache, (void *)(size_t)-1)) abo... | 395,199,671,194,911,300,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,074 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedprealloc2(nedpool *p, void *mem, size_t size, size_t alignment, unsigned flags) THROWSPEC
{
void *ret=0;
threadcache *tc;
int mymspace, isforeign=1;
size_t memsize;
if(!mem) return nedpmalloc2(p, size, alignment, flags);
#if REALLOC_ZERO_BYTES_FREES
if(!size... | 281,230,770,520,752,700,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,075 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | int nedpmalloc_trim(nedpool *p, size_t pad) THROWSPEC
{
int n, ret=0;
if(!p) { p=&syspool; if(!syspool.threads) InitPool(&syspool, 0, -1); }
for(n=0; p->m[n]; n++)
{
#if USE_ALLOCATOR==1
ret+=mspace_trim(p->m[n], pad);
#endif
}
return ret;
}
| 168,742,817,189,268,100,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,076 | nedmalloc | 2965eca30c408c13473c4146a9d47d547d288db1 | https://github.com/ned14/nedmalloc | https://github.com/ned14/nedmalloc/commit/2965eca30c408c13473c4146a9d47d547d288db1 | Avoid overflowing allocation size in calloc() | 0 | static FORCEINLINE mstate GetMSpace(nedpool *RESTRICT p, threadcache *RESTRICT tc, int mymspace, size_t size) THROWSPEC
{ /* Returns a locked and ready for use mspace */
mstate m=p->m[mymspace];
assert(m);
#if USE_LOCKS && USE_ALLOCATOR==1
if(!TRY_LOCK(&p->m[mymspace]->mutex)) m=FindMSpace(p, tc, &mymspace, siz... | 264,346,032,329,656,540,000,000,000,000,000,000,000 | None | null | [
"CWE-189"
] | CVE-2012-2675 | Multiple integer overflows in the (1) CallMalloc (malloc) and (2) nedpcalloc (calloc) functions in nedmalloc (nedmalloc.c) before 1.10 beta2 make it easier for context-dependent attackers to perform memory-related attacks such as buffer overflows via a large size value, which causes less memory to be allocated than exp... | https://nvd.nist.gov/vuln/detail/CVE-2012-2675 |
516,077 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | xstrncpy (char *dest, const char *src, size_t n) {
if ( (src == NULL) || (strcmp(src, "") == 0))
return;
strncpy(dest, src, n-1);
dest[n-1] = 0;
} | 122,377,016,732,258,460,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,078 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | xmallox (size_t len)
{
void *memres = malloc (len);
if (memres == NULL) {
fprintf(stderr, "Running Out of Memory!!!\n");
exit(EXIT_FAILURE);
}
return memres;
} | 267,149,825,782,236,400,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,079 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | connectINET(char *serverHost, uint16_t serverPort)
{
struct sockaddr_in server;
struct hostent *he;
int asockd;
struct sigaction action;
action.sa_handler = connect_timeout;
memset ((char *) &server, 0, sizeof (server));
server.sin_addr.s_addr = inet_addr(serverHost);
... | 327,157,570,503,902,840,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,080 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int extract_http_info(ci_request_t * req, ci_headers_list_t * req_header,
struct http_info *httpinf)
{
char *str;
int i = 0;
/* Format of the HTTP header we want to parse:
GET http://www.squid-cache.org/Doc/config/icap_service HTTP/1.1
*/
httpinf->url[0]='\0';
httpinf->method[0]... | 38,413,380,947,936,510,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,081 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | isIpAddress(char *src_addr)
{
char *ptr;
int address;
int i;
char *s = (char *) malloc (sizeof (char) * LOW_CHAR);
xstrncpy(s, src_addr, LOW_CHAR);
/* make sure we have numbers and dots only! */
if(strspn(s, "0123456789.") != strlen(s)) {
xfree(s);
return 1;
}
/* split up each number from... | 39,181,200,078,757,670,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,082 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | simple_pattern_compare(char *str, const int type)
{
int i = 0;
/* pass througth all regex pattern */
for (i = 0; i < pattc; i++) {
if ( (patterns[i].type == type) && (regexec(&patterns[i].regexv, str, 0, 0, 0) == 0) ) {
switch(type) {
/* return 1 if string matches whitelist pattern */
case WHITELIST:... | 327,469,503,178,919,500,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,083 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | ptrarray_length(char** arr)
{
int i = 0;
while(arr[i] != NULL) i++;
return i;
} | 36,077,118,199,634,656,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,084 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | void *squidclamav_init_request_data(ci_request_t * req)
{
int preview_size;
av_req_data_t *data;
preview_size = ci_req_preview_size(req);
ci_debug_printf(1, "DEBUG squidclamav_init_request_data: initializing request data handler.\n");
if (!(data = ci_object_pool_alloc(AVREQDATA_POOL))) {
ci_debu... | 154,336,488,643,169,630,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,085 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | growPatternArray (SCPattern item)
{
void *_tmp = NULL;
if (pattc == current_pattern_size) {
if (current_pattern_size == 0)
current_pattern_size = PATTERN_ARR_SIZE;
else
current_pattern_size += PATTERN_ARR_SIZE;
_tmp = realloc(pa... | 101,404,327,189,743,860,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,086 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | isPathExists(const char *path)
{
struct stat sb;
if ( (path == NULL) || (strcmp(path, "") == 0) ) return -1;
if (lstat(path, &sb) != 0) {
return -1;
}
return 0;
} | 304,209,070,110,354,340,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,087 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | dconnect ()
{
struct sockaddr_un userver;
int asockd;
memset ((char *) &userver, 0, sizeof (userver));
ci_debug_printf(1, "dconnect: entering.\n");
if (clamd_local != NULL) {
userver.sun_family = AF_UNIX;
xstrncpy (userver.sun_path, clamd_local, sizeof(userver.sun_path));
if ((asockd = so... | 124,931,206,651,369,080,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,088 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | trim(char *str)
{
int i = 0;
int j = 0;
/* Remove spaces and tabs from beginning */
while ( (str[i] == ' ') || (str[i] == '\t') ) {
i++;
}
if (i > 0) {
for (j = i; j < strlen(str); j++) {
str[j-i] = str[j];
}
str[j-i] = '\0';
}
/* Now remove spaces and tabs from end */
i = strlen(str) - 1;
while ... | 121,294,281,720,948,270,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,089 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | load_patterns()
{
char *buf = NULL;
FILE *fp = NULL;
if (isPathExists(CONFIG_FILE) == 0) {
fp = fopen(CONFIG_FILE, "rt");
if (debug > 0)
ci_debug_printf(0, "LOG load_patterns: Reading configuration from %s\n", CONFIG_FILE);
}
if (fp == NULL) {
ci_debug_printf(0, "FATAL load_patterns: una... | 185,680,919,696,318,100,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,090 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int squidclamav_check_preview_handler(char *preview_data, int preview_data_len, ci_request_t * req)
{
ci_headers_list_t *req_header;
struct http_info httpinf;
av_req_data_t *data = ci_service_data(req);
char *clientip;
struct hostent *clientname;
unsigned long ip;
char *username;
... | 275,224,704,382,283,940,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,091 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int squidclamav_write_to_net(char *buf, int len, ci_request_t * req)
{
int bytes;
av_req_data_t *data = ci_service_data(req);
if (!data)
return CI_ERROR;
if (data->blocked == 1 && data->error_page == 0) {
ci_debug_printf(2, "DEBUG squidclamav_write_to_net: ending here, content was block... | 87,170,797,559,948,070,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,092 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | void squidclamav_release_request_data(void *data)
{
if (data) {
ci_debug_printf(1, "DEBUG squidclamav_release_request_data: Releasing request data.\n");
if (((av_req_data_t *) data)->body) {
ci_simple_file_destroy(((av_req_data_t *) data)->body);
if (((av_req_data_t *) data)->url... | 222,168,850,827,686,500,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,093 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int squidclamav_post_init_service(ci_service_xdata_t * srv_xdata, struct ci_server_conf *server_conf)
{
if (squidguard == NULL) return 0;
ci_debug_printf(1, "DEBUG squidclamav_post_init_service: opening pipe to %s\n", squidguard);
if (create_pipe(squidguard) == 1) {
return 0;
}
return 1;
} | 245,762,403,121,021,000,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,094 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int create_pipe(char *command)
{
int pipe1[2];
int pipe2[2];
ci_debug_printf(1, "DEBUG create_pipe: Open pipe to squidGuard %s!\n", command);
if (command != NULL) {
if ( pipe(pipe1) < 0 || pipe(pipe2) < 0 ) {
ci_debug_printf(0, "ERROR create_pipe: unable to open pipe, disabling call to %s.\n", c... | 50,572,545,132,804,050,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,095 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int squidclamav_init_service(ci_service_xdata_t * srv_xdata,
struct ci_server_conf *server_conf)
{
unsigned int xops;
ci_debug_printf(1, "DEBUG squidclamav_init_service: Going to initialize squidclamav\n");
squidclamav_xdata = srv_xdata;
set_istag(squidclamav_xdata);
ci_... | 132,072,222,541,832,970,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,096 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | isPathSecure(const char *path)
{
struct stat sb;
/* no path => unreal, that's possible ! */
if (path == NULL) return -1;
/* file doesn't exist or access denied = secure */
/* fopen will fail */
if (lstat(path, &sb) != 0) return 0;
/* File is not a regular file => unsecure */
if ( S_IS... | 312,415,946,636,200,700,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,097 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | free_pipe ()
{
xfree(squidguard);
if (sgfpw) fclose(sgfpw);
if (sgfpr) fclose(sgfpr);
} | 271,039,925,012,182,240,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,098 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | xfree(void *s)
{
if (s != NULL)
free(s);
s = NULL;
} | 39,641,703,798,283,994,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,099 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int squidclamav_io(char *wbuf, int *wlen, char *rbuf, int *rlen, int iseof, ci_request_t * req)
{
int ret = CI_OK;
if (rbuf && rlen) {
*rlen = squidclamav_read_from_net(rbuf, *rlen, iseof, req);
if (*rlen == CI_ERROR)
return CI_ERROR;
else if (*rlen < 0)
ret = CI_OK;
... | 239,753,995,838,457,150,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,100 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | void set_istag(ci_service_xdata_t * srv_xdata)
{
char istag[SERVICE_ISTAG_SIZE + 1];
snprintf(istag, SERVICE_ISTAG_SIZE, "-%d-%s-%d%d",1, "squidclamav", 1, 0);
istag[SERVICE_ISTAG_SIZE] = '\0';
ci_service_set_istag(srv_xdata, istag);
ci_debug_printf(2, "DEBUG set_istag: setting istag to %s\n"... | 95,191,369,136,342,080,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,101 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | void generate_redirect_page(char * redirect, ci_request_t * req, av_req_data_t * data)
{
int new_size = 0;
char buf[MAX_URL_SIZE];
ci_membuf_t *error_page;
new_size = strlen(blocked_header_message) + strlen(redirect) + strlen(blocked_footer_message) + 10;
if ( ci_http_response_headers(req))
... | 293,050,401,812,949,850,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,102 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | add_pattern(char *s)
{
char *first = NULL;
char *type = NULL;
int stored = 0;
int regex_flags = REG_NOSUB;
SCPattern currItem;
char *end = NULL;
/* skip empty and commented lines */
if ( (xstrnlen(s, LOW_BUFF) == 0) || (strncmp(s, "#", 1) == 0)) return 1;
/* Config file directives are construct as follow: n... | 290,677,959,149,442,440,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,103 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | void cfgreload_command(char *name, int type, char **argv)
{
ci_debug_printf(1, "DEBUG cfgreload_command: reload configuration command received\n");
free_global();
free_pipe();
debug = 0;
statit = 0;
pattc = 0;
current_pattern_size = 0;
maxsize = 0;
logredir = 0;
dnslookup = 1;
... | 257,020,159,049,053,370,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,104 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | void connect_timeout() {
// doesn't actually need to do anything
} | 154,422,812,332,081,360,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,105 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | chomp (char *str)
{
size_t len = 0;
if (str == NULL) return;
len = strlen(str);
if ((len > 0) && str[len - 1] == 10) {
str[len - 1] = 0;
len--;
}
if ((len > 0) && str[len - 1] == 13)
str[len - 1] = 0;
return;
} | 68,827,489,434,909,350,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,106 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | xstrnlen(const char *s, size_t n)
{
const char *p = (const char *)memchr(s, 0, n);
return(p ? p-s : n);
} | 214,492,400,426,183,450,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
516,107 | squidclamav | 80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | https://github.com/darold/squidclamav | https://github.com/darold/squidclamav/commit/80f74451f628264d1d9a1f1c0bbcebc932ba5e00 | Add a workaround for a squidGuard bug that unescape the URL and send it back unescaped. This could conduct in wrong result and ssquidclamav crash especially with URL containing the %0D or %0A character. John Xue | 0 | int squidclamav_read_from_net(char *buf, int len, int iseof, ci_request_t * req)
{
av_req_data_t *data = ci_service_data(req);
int allow_transfer;
if (!data)
return CI_ERROR;
if (!data->body)
return len;
if (data->no_more_scan == 1) {
return ci_simple_file_write(data->body, buf, l... | 25,420,210,971,728,617,000,000,000,000,000,000,000 | None | null | [
"CWE-119"
] | CVE-2012-3501 | The squidclamav_check_preview_handler function in squidclamav.c in SquidClamav 5.x before 5.8 and 6.x before 6.7 passes an unescaped URL to a system command call, which allows remote attackers to cause a denial of service (daemon crash) via a URL with certain characters, as demonstrated using %0D or %0A. | https://nvd.nist.gov/vuln/detail/CVE-2012-3501 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.