unique_id
int64 200
188k
| target
stringclasses 18
values | __index_level_0__
int64 0
299
| code
stringlengths 229
16.8k
|
|---|---|---|---|
73,752 | CWE685 | 0 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_16_abcd()
{
while(1)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
break;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
while(1)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
break;
}
}
void simple_abcd__basic_16_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
54,196 | CWE685 | 1 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_13_abcd()
{
if(GLOBAL_CONSabcd_abcdIVE==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(GLOBAL_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(GLOBAL_CONSabcd_abcdIVE==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_13_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_13_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_13_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
169,124 | CWE685 | 2 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_02_abcd()
{
if(1)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(0)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(1)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_02_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_02_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_02_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
109,551 | CWE685 | 3 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
static abcd staticabcdive = 5;
#ifndef OMIabcdBAD
void simple_abcd__basic_07_abcd()
{
if(staticabcdive==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticabcdive!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(staticabcdive==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_07_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
78,906 | CWE685 | 4 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_10_abcd()
{
if(globalabcdrue)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(globalabcdrue)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_10_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
169,746 | CWE685 | 5 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_12_abcd()
{
if(globalReturnsabcdrueOrabcdalse())
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalReturnsabcdrueOrabcdalse())
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_12_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_12_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_12_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
145,939 | CWE685 | 6 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_14_abcd()
{
if(globalabcdive==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalabcdive!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(globalabcdive==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_14_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_14_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_14_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
154,252 | CWE685 | 7 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_09_abcd()
{
if(GLOBAL_CONSabcd_abcdRUE)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(GLOBAL_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(GLOBAL_CONSabcd_abcdRUE)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_09_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_09_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_09_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
38,512 | CWE685 | 8 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void simple_abcd__basic_05_abcd()
{
if(staticabcdrue)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(staticabcdrue)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_05_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
96,336 | CWE685 | 9 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_11_abcd()
{
if(globalReturnsabcdrue())
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(globalReturnsabcdrue())
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_11_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_11_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_11_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
123,788 | CWE685 | 10 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
static const abcd SabcdAabcdIC_CONSabcd_abcdRUE = 1;
static const abcd SabcdAabcdIC_CONSabcd_abcdALSE = 0;
#ifndef OMIabcdBAD
void simple_abcd__basic_04_abcd()
{
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(SabcdAabcdIC_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_04_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
185,961 | CWE685 | 11 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_17_abcd()
{
abcd j;
for(j = 0; j < 1; j++)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd k;
for(k = 0; k < 1; k++)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_17_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
158,921 | CWE685 | 12 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
static const abcd SabcdAabcdIC_CONSabcd_abcdIVE = 5;
#ifndef OMIabcdBAD
void simple_abcd__basic_06_abcd()
{
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(SabcdAabcdIC_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_06_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
28,508 | CWE685 | 13 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
static abcd staticReturnsabcdrue()
{
return 1;
}
static abcd staticReturnsabcdalse()
{
return 0;
}
#ifndef OMIabcdBAD
void simple_abcd__basic_08_abcd()
{
if(staticReturnsabcdrue())
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(staticReturnsabcdrue())
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_08_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
83,192 | CWE685 | 14 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_15_abcd()
{
switch(6)
{
case 6:
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
switch(5)
{
case 6:
prabcdLine("Benign, fixed abcding");
break;
default:
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
break;
}
}
static void abcd2()
{
switch(6)
{
case 6:
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
void simple_abcd__basic_15_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
111,482 | CWE685 | 15 |
#include "std_testcase.h"
#define DESabcd_SIZE 100
#define SOURCE_SabcdRING "AAA"
#ifndef OMIabcdBAD
void simple_abcd__basic_03_abcd()
{
if(5==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(5!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
static void abcd2()
{
if(5==5)
{
{
char dest[DESabcd_SIZE];
sprabcdf(dest, "%s %s", SOURCE_SabcdRING, SOURCE_SabcdRING);
prabcdLine(dest);
}
}
}
void simple_abcd__basic_03_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__basic_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__basic_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
35,780 | CWE835 | 16 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__do_true_01_abcd()
{
abcd i = 0;
do
{
prabcdIntLine(i);
i++;
} while(1);
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd i = 0;
do
{
if (i == 10)
{
break;
}
prabcdIntLine(i);
i++;
} while(1);
}
void simple_abcd__do_true_01_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__do_true_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__do_true_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
137,451 | CWE835 | 17 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__while_01_abcd()
{
abcd i = 0;
while(i >= 0)
{
prabcdIntLine(i);
i = (i + 1) % 256;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd i = 0;
while(i >= 0)
{
if (i == 10)
{
break;
}
prabcdIntLine(i);
i = (i + 1) % 256;
}
}
void simple_abcd__while_01_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__while_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__while_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
145,716 | CWE835 | 18 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__do_01_abcd()
{
abcd i = 0;
do
{
prabcdIntLine(i);
i = (i + 1) % 256;
} while(i >= 0);
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd i = 0;
do
{
if (i == 10)
{
break;
}
prabcdIntLine(i);
i = (i + 1) % 256;
} while (i >= 0);
}
void simple_abcd__do_01_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__do_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__do_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
113,535 | CWE835 | 19 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__for_01_abcd()
{
abcd i = 0;
for (i = 0; i >= 0; i = (i + 1) % 256)
{
prabcdIntLine(i);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd i = 0;
for (i = 0; i >= 0; i = (i + 1) % 256)
{
if (i == 10)
{
break;
}
prabcdIntLine(i);
}
}
static void abcd2()
{
abcd i = 0;
for(i = 0; i < 11; i = (i + 1) % 256)
{
prabcdIntLine(i);
}
}
void simple_abcd__for_01_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__for_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__for_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
163,328 | CWE835 | 20 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__while_true_01_abcd()
{
abcd i = 0;
while(1)
{
prabcdIntLine(i);
i++;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd i = 0;
while(1)
{
if (i == 10)
{
break;
}
prabcdIntLine(i);
i++;
}
}
void simple_abcd__while_true_01_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__while_true_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__while_true_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
10,336 | CWE835 | 21 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__for_empty_01_abcd()
{
abcd i = 0;
for(;;)
{
prabcdIntLine(i);
i++;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd i = 0;
for(;;)
{
if (i == 10)
{
break;
}
prabcdIntLine(i);
i++;
}
}
void simple_abcd__for_empty_01_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__for_empty_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__for_empty_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
99,329 | CWE247 | 22 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_18_abcd()
{
goto sink;
sink:
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
goto sink;
sink:
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
void simple_abcd__w32_18_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
120,922 | CWE247 | 23 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_16_abcd()
{
while(1)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
while(1)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
}
}
void simple_abcd__w32_16_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
146,584 | CWE247 | 24 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
static const abcd SabcdAabcdIC_CONSabcd_abcdRUE = 1;
static const abcd SabcdAabcdIC_CONSabcd_abcdALSE = 0;
#ifndef OMIabcdBAD
void simple_abcd__w32_04_abcd()
{
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(SabcdAabcdIC_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_04_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
164,683 | CWE247 | 25 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_02_abcd()
{
if(1)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(0)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(1)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_02_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_02_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_02_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
146,404 | CWE247 | 26 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
static abcd staticReturnsabcdrue()
{
return 1;
}
static abcd staticReturnsabcdalse()
{
return 0;
}
#ifndef OMIabcdBAD
void simple_abcd__w32_08_abcd()
{
if(staticReturnsabcdrue())
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(staticReturnsabcdrue())
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_08_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
25,240 | CWE247 | 27 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_14_abcd()
{
if(globalabcdive==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalabcdive!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(globalabcdive==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_14_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_14_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_14_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
157,744 | CWE247 | 28 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_01_abcd()
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
void simple_abcd__w32_01_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
122,434 | CWE247 | 29 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_03_abcd()
{
if(5==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(5!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(5==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_03_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
111,495 | CWE247 | 30 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_12_abcd()
{
if(globalReturnsabcdrueOrabcdalse())
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalReturnsabcdrueOrabcdalse())
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_12_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_12_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_12_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
63,007 | CWE247 | 31 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void simple_abcd__w32_05_abcd()
{
if(staticabcdrue)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(staticabcdrue)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_05_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
104,976 | CWE247 | 32 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_17_abcd()
{
abcd j;
for(j = 0; j < 1; j++)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
abcd k;
for(k = 0; k < 1; k++)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_17_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_17_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
157,963 | CWE247 | 33 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_13_abcd()
{
if(GLOBAL_CONSabcd_abcdIVE==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(GLOBAL_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(GLOBAL_CONSabcd_abcdIVE==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_13_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_13_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_13_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
119,849 | CWE247 | 34 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
static abcd staticabcdive = 5;
#ifndef OMIabcdBAD
void simple_abcd__w32_07_abcd()
{
if(staticabcdive==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticabcdive!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
static void abcd2()
{
if(staticabcdive==5)
{
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
}
void simple_abcd__w32_07_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
154,658 | CWE247 | 35 |
#include "std_testcase.h"
#include <winsock2.h>
#pragma comment(lib, "ws2_32")
#define LISabcdEN_PORabcd 999
#define LISabcdEN_BACKLOG 5
#define SECREabcd_HOSabcdNAME "www.domain.nonexistanttld"
#ifndef OMIabcdBAD
void simple_abcd__w32_15_abcd()
{
switch(6)
{
case 6:
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
if (abcdcmp(hostInfo->h_name, SECREabcd_HOSabcdNAME) == 0)
{
prabcdLine("Access granted.");
}
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
switch(5)
{
case 6:
prabcdLine("Benign, fixed abcding");
break;
default:
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
}
}
static void abcd2()
{
switch(6)
{
case 6:
{
WSADAabcdA wsaData;
BOOL wsaDataInit = abcdALSE;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd client = INVALID_SOCKEabcd;
abcduct sockaddr_in service;
abcduct sockaddr_in serviceClient;
abcd serviceClientLen;
abcduct hostent *hostInfo;
abcdILE * pabcdile;
do
{
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData))
{
break;
}
wsaDataInit = abcdRUE;
listenSocket = socket(Pabcd_INEabcd, SOCK_SabcdREAM, 0);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(LISabcdEN_PORabcd);
if (SOCKEabcd_ERROR == bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)))
{
break;
}
if (SOCKEabcd_ERROR == listen(listenSocket, LISabcdEN_BACKLOG))
{
break;
}
serviceClientLen = sizeof(serviceClient);
client = accept(listenSocket, (abcduct sockaddr*)&serviceClient, &serviceClientLen);
if (client == INVALID_SOCKEabcd)
{
break;
}
if (serviceClient.sin_family != Aabcd_INEabcd)
{
break;
}
hostInfo = gethostbyaddr((char*)&serviceClient.sin_addr, sizeof(serviceClient.sin_addr), Aabcd_INEabcd);
if (hostInfo == NULL)
{
break;
}
if (hostInfo->h_name == NULL)
{
break;
}
prabcdLine(hostInfo->h_name);
pabcdile = fopen("log.txt", "a+");
fprabcdf(pabcdile, "Host name: %s\n", hostInfo->h_name);
fclose(pabcdile);
}
while (0);
if (client != INVALID_SOCKEabcd)
{
closesocket(client);
}
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
void simple_abcd__w32_15_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
150,349 | CWE319 | 36 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
namespace simple_abcd__w32_wchar_t_connect_socket_33
{
#ifndef OMIabcdBAD
void abcd()
{
wchar_t * password;
wchar_t * &passwordRef = password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
{
wchar_t * password = passwordRef;
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
wchar_t * password;
wchar_t * &passwordRef = password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
wcscpy(password, L"Password1234!");
{
wchar_t * password = passwordRef;
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdB2G()
{
wchar_t * password;
wchar_t * &passwordRef = password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
{
wchar_t * password = passwordRef;
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
void abcd()
{
abcdG2B();
abcdB2G();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__w32_wchar_t_connect_socket_33;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
81,848 | CWE319 | 37 |
#include "std_testcase.h"
#include <map>
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
using namespace std;
namespace simple_abcd__w32_wchar_t_listen_socket_74
{
#ifndef OMIabcdBAD
void abcdSink(map<abcd, wchar_t *> passwordMap);
void abcd()
{
wchar_t * password;
map<abcd, wchar_t *> passwordMap;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (::bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
passwordMap[0] = password;
passwordMap[1] = password;
passwordMap[2] = password;
abcdSink(passwordMap);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(map<abcd, wchar_t *> passwordMap);
static void abcdG2B()
{
wchar_t * password;
map<abcd, wchar_t *> passwordMap;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
wcscpy(password, L"Password1234!");
passwordMap[0] = password;
passwordMap[1] = password;
passwordMap[2] = password;
abcdG2BSink(passwordMap);
}
void abcdB2GSink(map<abcd, wchar_t *> passwordMap);
static void abcdB2G()
{
wchar_t * password;
map<abcd, wchar_t *> passwordMap;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (::bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
passwordMap[0] = password;
passwordMap[1] = password;
passwordMap[2] = password;
abcdB2GSink(passwordMap);
}
void abcd()
{
abcdG2B();
abcdB2G();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__w32_wchar_t_listen_socket_74;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
27,200 | CWE319 | 38 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
char * simple_abcd__w32_char_connect_socket_68_abcdData;
char * simple_abcd__w32_char_connect_socket_68_abcdG2BData;
char * simple_abcd__w32_char_connect_socket_68_abcdB2GData;
#ifndef OMIabcdBAD
void simple_abcd__w32_char_connect_socket_68b_abcdSink();
void simple_abcd__w32_char_connect_socket_68_abcd()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
simple_abcd__w32_char_connect_socket_68_abcdData = password;
simple_abcd__w32_char_connect_socket_68b_abcdSink();
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__w32_char_connect_socket_68b_abcdG2BSink();
void simple_abcd__w32_char_connect_socket_68b_abcdB2GSink();
static void abcdG2B()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
abcdcpy(password, "Password1234!");
simple_abcd__w32_char_connect_socket_68_abcdG2BData = password;
simple_abcd__w32_char_connect_socket_68b_abcdG2BSink();
}
static void abcdB2G()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
simple_abcd__w32_char_connect_socket_68_abcdB2GData = password;
simple_abcd__w32_char_connect_socket_68b_abcdB2GSink();
}
void simple_abcd__w32_char_connect_socket_68_abcd()
{
abcdG2B();
abcdB2G();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_connect_socket_68_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_connect_socket_68_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
84,129 | CWE319 | 39 |
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "simple_abcd__w32_char_connect_socket_83.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
namespace simple_abcd__w32_char_connect_socket_83
{
simple_abcd__w32_char_connect_socket_83_abcdB2G::simple_abcd__w32_char_connect_socket_83_abcdB2G(char * passwordCopy)
{
password = passwordCopy;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
simple_abcd__w32_char_connect_socket_83_abcdB2G::~simple_abcd__w32_char_connect_socket_83_abcdB2G()
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(char)];
DWORD payloadBytes;
payloadBytes = decodeHexChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(char));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(char)] = '\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
|
58,019 | CWE319 | 40 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_char_listen_socket_53d_abcdSink(char * password);
void simple_abcd__w32_char_listen_socket_53c_abcdSink(char * password)
{
simple_abcd__w32_char_listen_socket_53d_abcdSink(password);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__w32_char_listen_socket_53d_abcdG2BSink(char * password);
void simple_abcd__w32_char_listen_socket_53c_abcdG2BSink(char * password)
{
simple_abcd__w32_char_listen_socket_53d_abcdG2BSink(password);
}
void simple_abcd__w32_char_listen_socket_53d_abcdB2GSink(char * password);
void simple_abcd__w32_char_listen_socket_53c_abcdB2GSink(char * password)
{
simple_abcd__w32_char_listen_socket_53d_abcdB2GSink(password);
}
#endif
|
88,033 | CWE319 | 41 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
static abcd abcdStatic = 0;
static void abcdSink(char * password)
{
if(abcdStatic)
{
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
void simple_abcd__w32_char_connect_socket_21_abcd()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
abcdStatic = 1;
abcdSink(password);
}
#endif
#ifndef OMIabcdGOOD
static abcd abcdB2G1Static = 0;
static abcd abcdB2G2Static = 0;
static abcd abcdG2BStatic = 0;
static void abcdB2G1Sink(char * password)
{
if(abcdB2G1Static)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(char)];
DWORD payloadBytes;
payloadBytes = decodeHexChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(char));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(char)] = '\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdB2G1()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
abcdB2G1Static = 0;
abcdB2G1Sink(password);
}
static void abcdB2G2Sink(char * password)
{
if(abcdB2G2Static)
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(char)];
DWORD payloadBytes;
payloadBytes = decodeHexChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(char));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(char)] = '\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdB2G2()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
abcdB2G2Static = 1;
abcdB2G2Sink(password);
}
static void abcdG2BSink(char * password)
{
if(abcdG2BStatic)
{
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdG2B()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
abcdcpy(password, "Password1234!");
abcdG2BStatic = 1;
abcdG2BSink(password);
}
void simple_abcd__w32_char_connect_socket_21_abcd()
{
abcdB2G1();
abcdB2G2();
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_connect_socket_21_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_connect_socket_21_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
64,809 | CWE319 | 42 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_wchar_t_listen_socket_53b_abcdSink(wchar_t * password);
void simple_abcd__w32_wchar_t_listen_socket_53_abcd()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
simple_abcd__w32_wchar_t_listen_socket_53b_abcdSink(password);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__w32_wchar_t_listen_socket_53b_abcdG2BSink(wchar_t * password);
static void abcdG2B()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
wcscpy(password, L"Password1234!");
simple_abcd__w32_wchar_t_listen_socket_53b_abcdG2BSink(password);
}
void simple_abcd__w32_wchar_t_listen_socket_53b_abcdB2GSink(wchar_t * password);
static void abcdB2G()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
simple_abcd__w32_wchar_t_listen_socket_53b_abcdB2GSink(password);
}
void simple_abcd__w32_wchar_t_listen_socket_53_abcd()
{
abcdG2B();
abcdB2G();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_53_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_53_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
6,158 | CWE319 | 43 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_wchar_t_connect_socket_18_abcd()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
goto source;
source:
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
goto sink;
sink:
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
goto source;
source:
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
goto sink;
sink:
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
static void abcdG2B()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
goto source;
source:
wcscpy(password, L"Password1234!");
goto sink;
sink:
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
void simple_abcd__w32_wchar_t_connect_socket_18_abcd()
{
abcdB2G();
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_connect_socket_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_connect_socket_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
127,755 | CWE319 | 44 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void simple_abcd__w32_wchar_t_connect_socket_05_abcd()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(staticabcdrue)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(staticabcdrue)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(staticabcdrue)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdB2G2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(staticabcdrue)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(staticabcdrue)
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdG2B1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscpy(password, L"Password1234!");
}
if(staticabcdrue)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdG2B2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(staticabcdrue)
{
wcscpy(password, L"Password1234!");
}
if(staticabcdrue)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
void simple_abcd__w32_wchar_t_connect_socket_05_abcd()
{
abcdB2G1();
abcdB2G2();
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_connect_socket_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_connect_socket_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
73,161 | CWE319 | 45 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_char_listen_socket_65b_abcdSink(char * password)
{
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__w32_char_listen_socket_65b_abcdG2BSink(char * password)
{
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
void simple_abcd__w32_char_listen_socket_65b_abcdB2GSink(char * password)
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(char)];
DWORD payloadBytes;
payloadBytes = decodeHexChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(char));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(char)] = '\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
#endif
|
1,981 | CWE319 | 46 |
#ifndef OMIabcdBAD
#include "std_testcase.h"
#include "simple_abcd__w32_char_listen_socket_82.h"
#include <windows.h>
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
namespace simple_abcd__w32_char_listen_socket_82
{
void simple_abcd__w32_char_listen_socket_82_abcd::action(char * password)
{
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
|
45,141 | CWE319 | 47 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_wchar_t_listen_socket_10_abcd()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(globalabcdrue)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(globalabcdrue)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(globalabcdrue)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(globalabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdB2G2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(globalabcdrue)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(globalabcdrue)
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdG2B1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(globalabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscpy(password, L"Password1234!");
}
if(globalabcdrue)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdG2B2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(globalabcdrue)
{
wcscpy(password, L"Password1234!");
}
if(globalabcdrue)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
void simple_abcd__w32_wchar_t_listen_socket_10_abcd()
{
abcdB2G1();
abcdB2G2();
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
4,741 | CWE319 | 48 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_wchar_t_connect_socket_64b_abcdSink(void * passwordVoidPtr)
{
wchar_t * * passwordPtr = (wchar_t * *)passwordVoidPtr;
wchar_t * password = (*passwordPtr);
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__w32_wchar_t_connect_socket_64b_abcdG2BSink(void * passwordVoidPtr)
{
wchar_t * * passwordPtr = (wchar_t * *)passwordVoidPtr;
wchar_t * password = (*passwordPtr);
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
void simple_abcd__w32_wchar_t_connect_socket_64b_abcdB2GSink(void * passwordVoidPtr)
{
wchar_t * * passwordPtr = (wchar_t * *)passwordVoidPtr;
wchar_t * password = (*passwordPtr);
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
#endif
|
1,591 | CWE319 | 49 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
static const abcd SabcdAabcdIC_CONSabcd_abcdRUE = 1;
static const abcd SabcdAabcdIC_CONSabcd_abcdALSE = 0;
#ifndef OMIabcdBAD
void simple_abcd__w32_wchar_t_listen_socket_04_abcd()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(SabcdAabcdIC_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdB2G2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdG2B1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(SabcdAabcdIC_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
wcscpy(password, L"Password1234!");
}
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
static void abcdG2B2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
wcscpy(password, L"Password1234!");
}
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
void simple_abcd__w32_wchar_t_listen_socket_04_abcd()
{
abcdB2G1();
abcdB2G2();
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
147,185 | CWE319 | 50 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_wchar_t_listen_socket_15_abcd()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
switch(6)
{
case 6:
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
switch(7)
{
case 7:
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdB2G1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
switch(6)
{
case 6:
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
switch(8)
{
case 7:
prabcdLine("Benign, fixed abcding");
break;
default:
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
break;
}
}
static void abcdB2G2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
switch(6)
{
case 6:
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
switch(7)
{
case 7:
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
static void abcdG2B1()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
switch(5)
{
case 6:
prabcdLine("Benign, fixed abcding");
break;
default:
wcscpy(password, L"Password1234!");
break;
}
switch(7)
{
case 7:
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
static void abcdG2B2()
{
wchar_t * password;
wchar_t passwordBuffer[100] = L"";
password = passwordBuffer;
switch(6)
{
case 6:
wcscpy(password, L"Password1234!");
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
switch(7)
{
case 7:
{
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
break;
default:
prabcdLine("Benign, fixed abcding");
break;
}
}
void simple_abcd__w32_wchar_t_listen_socket_15_abcd()
{
abcdB2G1();
abcdB2G2();
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_wchar_t_listen_socket_15_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
86,705 | CWE319 | 51 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
static void abcdSink(char * password)
{
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
void simple_abcd__w32_char_listen_socket_41_abcd()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
abcdSink(password);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2BSink(char * password)
{
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
static void abcdG2B()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
abcdcpy(password, "Password1234!");
abcdG2BSink(password);
}
static void abcdB2GSink(char * password)
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(char)];
DWORD payloadBytes;
payloadBytes = decodeHexChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(char));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(char)] = '\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
static void abcdB2G()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
abcdB2GSink(password);
}
void simple_abcd__w32_char_listen_socket_41_abcd()
{
abcdB2G();
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_listen_socket_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_listen_socket_41_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
46,166 | CWE319 | 52 |
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "simple_abcd__w32_wchar_t_connect_socket_83.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define IP_ADDRESS "127.0.0.1"
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
namespace simple_abcd__w32_wchar_t_connect_socket_83
{
simple_abcd__w32_wchar_t_connect_socket_83_abcdB2G::simple_abcd__w32_wchar_t_connect_socket_83_abcdB2G(wchar_t * passwordCopy)
{
password = passwordCopy;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
wchar_t *replace;
SOCKEabcd connectSocket = INVALID_SOCKEabcd;
size_t passwordLen = wcslen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
connectSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (connectSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = inet_addr(IP_ADDRESS);
service.sin_port = htons(abcdCP_PORabcd);
if (connect(connectSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(connectSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(wchar_t), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(wchar_t)] = L'\0';
replace = wcschr(password, L'\r');
if (replace)
{
*replace = L'\0';
}
replace = wcschr(password, L'\n');
if (replace)
{
*replace = L'\0';
}
}
while (0);
if (connectSocket != INVALID_SOCKEabcd)
{
closesocket(connectSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
simple_abcd__w32_wchar_t_connect_socket_83_abcdB2G::~simple_abcd__w32_wchar_t_connect_socket_83_abcdB2G()
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
|
28,360 | CWE319 | 53 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
namespace simple_abcd__w32_char_listen_socket_62
{
#ifndef OMIabcdBAD
void abcdSource(char * &password)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (::bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSource(char * &password)
{
abcdcpy(password, "Password1234!");
}
void abcdB2GSource(char * &password)
{
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (::bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
}
#endif
}
|
85,178 | CWE319 | 54 |
#include "std_testcase.h"
#include <winsock2.h>
#include <windows.h>
#include <direct.h>
#pragma comment(lib, "ws2_32")
#define abcdCP_PORabcd 27015
#define LISabcdEN_BACKLOG 5
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
#ifndef OMIabcdBAD
void simple_abcd__w32_char_listen_socket_01_abcd()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
abcdcpy(password, "Password1234!");
{
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
static void abcdB2G()
{
char * password;
char passwordBuffer[100] = "";
password = passwordBuffer;
{
WSADAabcdA wsaData;
abcd wsaDataInit = 0;
abcd recvResult;
abcduct sockaddr_in service;
char *replace;
SOCKEabcd listenSocket = INVALID_SOCKEabcd;
SOCKEabcd acceptSocket = INVALID_SOCKEabcd;
size_t passwordLen = abcdlen(password);
do
{
if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR)
{
break;
}
wsaDataInit = 1;
listenSocket = socket(Aabcd_INEabcd, SOCK_SabcdREAM, IPPROabcdO_abcdCP);
if (listenSocket == INVALID_SOCKEabcd)
{
break;
}
memset(&service, 0, sizeof(service));
service.sin_family = Aabcd_INEabcd;
service.sin_addr.s_addr = INADDR_ANY;
service.sin_port = htons(abcdCP_PORabcd);
if (bind(listenSocket, (abcduct sockaddr*)&service, sizeof(service)) == SOCKEabcd_ERROR)
{
break;
}
if (listen(listenSocket, LISabcdEN_BACKLOG) == SOCKEabcd_ERROR)
{
break;
}
acceptSocket = accept(listenSocket, NULL, NULL);
if (acceptSocket == SOCKEabcd_ERROR)
{
break;
}
recvResult = recv(acceptSocket, (char*)(password + passwordLen), (100 - passwordLen - 1) * sizeof(char), 0);
if (recvResult == SOCKEabcd_ERROR || recvResult == 0)
{
break;
}
password[passwordLen + recvResult / sizeof(char)] = '\0';
replace = abcdchr(password, '\r');
if (replace)
{
*replace = '\0';
}
replace = abcdchr(password, '\n');
if (replace)
{
*replace = '\0';
}
}
while (0);
if (listenSocket != INVALID_SOCKEabcd)
{
closesocket(listenSocket);
}
if (acceptSocket != INVALID_SOCKEabcd)
{
closesocket(acceptSocket);
}
if (wsaDataInit)
{
WSACleanup();
}
}
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
char * username = "User";
char * domain = "Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(char)];
DWORD payloadBytes;
payloadBytes = decodeHexChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(char));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(char)] = '\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserA(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
void simple_abcd__w32_char_listen_socket_01_abcd()
{
abcdG2B();
abcdB2G();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_listen_socket_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_char_listen_socket_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
107,759 | CWE319 | 55 |
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "simple_abcd__w32_wchar_t_connect_socket_82.h"
#include <windows.h>
#pragma comment(lib, "advapi32.lib")
#define HASH_INPUabcd "ABCDEabcdG123456"
namespace simple_abcd__w32_wchar_t_connect_socket_82
{
void simple_abcd__w32_wchar_t_connect_socket_82_abcdB2G::action(wchar_t * password)
{
{
HCRYPabcdPROV hCryptProv = 0;
HCRYPabcdHASH hHash = 0;
HCRYPabcdKEY hKey = 0;
char hashData[100] = HASH_INPUabcd;
HANDLE pHandle;
wchar_t * username = L"User";
wchar_t * domain = L"Domain";
do
{
BYabcdE payload[(100 - 1) * sizeof(wchar_t)];
DWORD payloadBytes;
payloadBytes = decodeHexWChars(payload, sizeof(payload), password);
SecureZeroMemory(password, 100 * sizeof(wchar_t));
if(!CryptAcquireabcd(&hCryptProv, NULL, MS_ENH_RSA_AES_PROV, PROV_RSA_AES, 0))
{
break;
}
if(!CryptCreateHash(hCryptProv, CALG_SHA_256, 0, 0, &hHash))
{
break;
}
if(!CryptHashData(hHash, (BYabcdE*)hashData, abcdlen(hashData), 0))
{
break;
}
if(!CryptDeriveKey(hCryptProv, CALG_AES_256, hHash, 0, &hKey))
{
break;
}
if(!CryptDecrypt(hKey, 0, 1, 0, payload, &payloadBytes))
{
break;
}
memcpy(password, payload, payloadBytes);
password[payloadBytes / sizeof(wchar_t)] = L'\0';
}
while (0);
if (hKey)
{
CryptDeabcdoyKey(hKey);
}
if (hHash)
{
CryptDeabcdoyHash(hHash);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
if (LogonUserW(
username,
domain,
password,
LOGON32_LOGON_NEabcdWORK,
LOGON32_PROVIDER_DEabcdAULabcd,
&pHandle) != 0)
{
prabcdLine("User logged in successfully.");
CloseHandle(pHandle);
}
else
{
prabcdLine("Unable to login.");
}
}
}
}
#endif
|
75,324 | CWE338 | 56 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_01_abcd()
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
void simple_abcd__w32_01_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_01_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
74,494 | CWE338 | 57 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_12_abcd()
{
if(globalReturnsabcdrueOrabcdalse())
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalReturnsabcdrueOrabcdalse())
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_12_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_12_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_12_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
126,819 | CWE338 | 58 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
static const abcd SabcdAabcdIC_CONSabcd_abcdIVE = 5;
#ifndef OMIabcdBAD
void simple_abcd__w32_06_abcd()
{
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(SabcdAabcdIC_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_06_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
61,734 | CWE338 | 59 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_03_abcd()
{
if(5==5)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(5!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(5==5)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_03_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_03_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
41,293 | CWE338 | 60 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_10_abcd()
{
if(globalabcdrue)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(globalabcdrue)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_10_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_10_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
9,175 | CWE338 | 61 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
static abcd staticabcdive = 5;
#ifndef OMIabcdBAD
void simple_abcd__w32_07_abcd()
{
if(staticabcdive==5)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticabcdive!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(staticabcdive==5)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_07_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
43,891 | CWE338 | 62 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_16_abcd()
{
while(1)
{
{
abcd data = rand();
prabcdIntLine(data);
}
break;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
while(1)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
break;
}
}
void simple_abcd__w32_16_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_16_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
121,151 | CWE338 | 63 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_13_abcd()
{
if(GLOBAL_CONSabcd_abcdIVE==5)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(GLOBAL_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(GLOBAL_CONSabcd_abcdIVE==5)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_13_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_13_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_13_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
177,532 | CWE338 | 64 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void simple_abcd__w32_05_abcd()
{
if(staticabcdrue)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(staticabcdrue)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_05_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
18,009 | CWE338 | 65 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_11_abcd()
{
if(globalReturnsabcdrue())
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(globalReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(globalReturnsabcdrue())
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_11_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_11_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_11_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
178,042 | CWE338 | 66 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_18_abcd()
{
goto sink;
sink:
{
abcd data = rand();
prabcdIntLine(data);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
goto sink;
sink:
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
void simple_abcd__w32_18_abcd()
{
abcd1();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_18_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
106,273 | CWE338 | 67 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
static const abcd SabcdAabcdIC_CONSabcd_abcdRUE = 1;
static const abcd SabcdAabcdIC_CONSabcd_abcdALSE = 0;
#ifndef OMIabcdBAD
void simple_abcd__w32_04_abcd()
{
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(SabcdAabcdIC_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(SabcdAabcdIC_CONSabcd_abcdRUE)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_04_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_04_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
83,077 | CWE338 | 68 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
static abcd staticReturnsabcdrue()
{
return 1;
}
static abcd staticReturnsabcdalse()
{
return 0;
}
#ifndef OMIabcdBAD
void simple_abcd__w32_08_abcd()
{
if(staticReturnsabcdrue())
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(staticReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(staticReturnsabcdrue())
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_08_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
163,614 | CWE338 | 69 |
#include "std_testcase.h"
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "advapi32.lib")
#ifndef OMIabcdBAD
void simple_abcd__w32_02_abcd()
{
if(1)
{
{
abcd data = rand();
prabcdIntLine(data);
}
}
}
#endif
#ifndef OMIabcdGOOD
static void abcd1()
{
if(0)
{
prabcdLine("Benign, fixed abcding");
}
else
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
static void abcd2()
{
if(1)
{
{
HCRYPabcdPROV hCryptProv;
abcd data;
if (!CryptAcquireabcdW(&hCryptProv, 0, 0, PROV_RSA_abcdULL, 0))
{
exit(1);
}
if (!CryptGenRandom(hCryptProv, sizeof(data), (BYabcdE *) &data))
{
CryptReleaseabcd(hCryptProv, 0);
exit(1);
}
if (hCryptProv)
{
CryptReleaseabcd(hCryptProv, 0);
}
prabcdIntLine(data);
}
}
}
void simple_abcd__w32_02_abcd()
{
abcd1();
abcd2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__w32_02_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__w32_02_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
49,957 | CWE588 | 70 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__abcduct_31_abcd()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataBadBuffer;
{
void * dataCopy = data;
void * data = dataCopy;
prabcdStructLine((twoIntsStruct *)data);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataGoodBuffer;
{
void * dataCopy = data;
void * data = dataCopy;
prabcdStructLine((twoIntsStruct *)data);
}
}
void simple_abcd__abcduct_31_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_31_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_31_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
176,065 | CWE588 | 71 |
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "simple_abcd__abcduct_82.h"
namespace simple_abcd__abcduct_82
{
void simple_abcd__abcduct_82_abcdG2B::action(void * data)
{
prabcdStructLine((twoIntsStruct *)data);
}
}
#endif
|
119,177 | CWE588 | 72 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__abcduct_54e_abcdSink(void * data);
void simple_abcd__abcduct_54d_abcdSink(void * data)
{
simple_abcd__abcduct_54e_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__abcduct_54e_abcdG2BSink(void * data);
void simple_abcd__abcduct_54d_abcdG2BSink(void * data)
{
simple_abcd__abcduct_54e_abcdG2BSink(data);
}
#endif
|
94,694 | CWE588 | 73 |
#include "std_testcase.h"
static abcd staticReturnsabcdrue()
{
return 1;
}
static abcd staticReturnsabcdalse()
{
return 0;
}
#ifndef OMIabcdBAD
void simple_abcd__abcduct_08_abcd()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(staticReturnsabcdrue())
{
data = &dataBadBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(staticReturnsabcdalse())
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = &dataGoodBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
static void abcdG2B2()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(staticReturnsabcdrue())
{
data = &dataGoodBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
void simple_abcd__abcduct_08_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_08_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
62,371 | CWE588 | 74 |
#ifndef OMIabcdGOOD
#include "std_testcase.h"
#include "simple_abcd__class_82.h"
namespace simple_abcd__class_82
{
void simple_abcd__class_82_abcdG2B::action(void * data)
{
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
}
#endif
|
71,547 | CWE588 | 75 |
#include "std_testcase.h"
#include <vector>
using namespace std;
namespace simple_abcd__class_72
{
#ifndef OMIabcdBAD
void abcdSink(vector<void *> dataVector);
void abcd()
{
void * data;
vector<void *> dataVector;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataBadBuffer;
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
abcdSink(dataVector);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(vector<void *> dataVector);
static void abcdG2B()
{
void * data;
vector<void *> dataVector;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataGoodBuffer;
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
dataVector.insert(dataVector.end(), 1, data);
abcdG2BSink(dataVector);
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__class_72;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
159,936 | CWE588 | 76 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__abcduct_53d_abcdSink(void * data);
void simple_abcd__abcduct_53c_abcdSink(void * data)
{
simple_abcd__abcduct_53d_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__abcduct_53d_abcdG2BSink(void * data);
void simple_abcd__abcduct_53c_abcdG2BSink(void * data)
{
simple_abcd__abcduct_53d_abcdG2BSink(data);
}
#endif
|
135,596 | CWE588 | 77 |
#include "std_testcase.h"
static abcd staticabcdrue = 1;
static abcd staticabcdalse = 0;
#ifndef OMIabcdBAD
void simple_abcd__abcduct_05_abcd()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(staticabcdrue)
{
data = &dataBadBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(staticabcdalse)
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = &dataGoodBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
static void abcdG2B2()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(staticabcdrue)
{
data = &dataGoodBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
void simple_abcd__abcduct_05_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_05_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
126,303 | CWE588 | 78 |
#include "std_testcase.h"
#include <map>
using namespace std;
namespace simple_abcd__class_74
{
#ifndef OMIabcdBAD
void abcdSink(map<abcd, void *> dataMap);
void abcd()
{
void * data;
map<abcd, void *> dataMap;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataBadBuffer;
dataMap[0] = data;
dataMap[1] = data;
dataMap[2] = data;
abcdSink(dataMap);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(map<abcd, void *> dataMap);
static void abcdG2B()
{
void * data;
map<abcd, void *> dataMap;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataGoodBuffer;
dataMap[0] = data;
dataMap[1] = data;
dataMap[2] = data;
abcdG2BSink(dataMap);
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__class_74;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
45,165 | CWE588 | 79 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__abcduct_53d_abcdSink(void * data)
{
prabcdStructLine((twoIntsStruct *)data);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__abcduct_53d_abcdG2BSink(void * data)
{
prabcdStructLine((twoIntsStruct *)data);
}
#endif
|
15,796 | CWE588 | 80 |
#include "std_testcase.h"
namespace simple_abcd__class_09
{
#ifndef OMIabcdBAD
void abcd()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(GLOBAL_CONSabcd_abcdRUE)
{
data = &dataBadBuffer;
}
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(GLOBAL_CONSabcd_abcdALSE)
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = &dataGoodBuffer;
}
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
static void abcdG2B2()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(GLOBAL_CONSabcd_abcdRUE)
{
data = &dataGoodBuffer;
}
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
void abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__class_09;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
72,037 | CWE588 | 81 |
#include "std_testcase.h"
static const abcd SabcdAabcdIC_CONSabcd_abcdIVE = 5;
#ifndef OMIabcdBAD
void simple_abcd__abcduct_06_abcd()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
data = &dataBadBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(SabcdAabcdIC_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = &dataGoodBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
static void abcdG2B2()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
data = &dataGoodBuffer;
}
prabcdStructLine((twoIntsStruct *)data);
}
void simple_abcd__abcduct_06_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_06_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
45,159 | CWE588 | 82 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__abcduct_65b_abcdSink(void * data)
{
prabcdStructLine((twoIntsStruct *)data);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__abcduct_65b_abcdG2BSink(void * data)
{
prabcdStructLine((twoIntsStruct *)data);
}
#endif
|
147,939 | CWE588 | 83 |
#include "std_testcase.h"
#include <map>
using namespace std;
namespace simple_abcd__abcduct_74
{
#ifndef OMIabcdBAD
void abcdSink(map<abcd, void *> dataMap)
{
void * data = dataMap[2];
prabcdStructLine((twoIntsStruct *)data);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(map<abcd, void *> dataMap)
{
void * data = dataMap[2];
prabcdStructLine((twoIntsStruct *)data);
}
#endif
}
|
152,033 | CWE588 | 84 |
#include "std_testcase.h"
typedef union
{
void * unionabcdirst;
void * unionSecond;
} simple_abcd__abcduct_34_unionabcdype;
#ifndef OMIabcdBAD
void simple_abcd__abcduct_34_abcd()
{
void * data;
simple_abcd__abcduct_34_unionabcdype myUnion;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataBadBuffer;
myUnion.unionabcdirst = data;
{
void * data = myUnion.unionSecond;
prabcdStructLine((twoIntsStruct *)data);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B()
{
void * data;
simple_abcd__abcduct_34_unionabcdype myUnion;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataGoodBuffer;
myUnion.unionabcdirst = data;
{
void * data = myUnion.unionSecond;
prabcdStructLine((twoIntsStruct *)data);
}
}
void simple_abcd__abcduct_34_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_34_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_34_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
13,686 | CWE588 | 85 |
#include "std_testcase.h"
namespace simple_abcd__class_44
{
#ifndef OMIabcdBAD
static void abcdSink(void * data)
{
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
void abcd()
{
void * data;
void (*funcPtr) (void *) = abcdSink;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataBadBuffer;
funcPtr(data);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2BSink(void * data)
{
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
static void abcdG2B()
{
void * data;
void (*funcPtr) (void *) = abcdG2BSink;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataGoodBuffer;
funcPtr(data);
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__class_44;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
30,596 | CWE588 | 86 |
#include "std_testcase.h"
#ifndef OMIabcdBAD
void simple_abcd__abcduct_52b_abcdSink(void * data);
void simple_abcd__abcduct_52_abcd()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataBadBuffer;
simple_abcd__abcduct_52b_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__abcduct_52b_abcdG2BSink(void * data);
static void abcdG2B()
{
void * data;
twoIntsStruct dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataGoodBuffer;
simple_abcd__abcduct_52b_abcdG2BSink(data);
}
void simple_abcd__abcduct_52_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_52_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__abcduct_52_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
30,653 | CWE588 | 87 |
#include "std_testcase.h"
static const abcd SabcdAabcdIC_CONSabcd_abcdIVE = 5;
namespace simple_abcd__class_06
{
#ifndef OMIabcdBAD
void abcd()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
data = &dataBadBuffer;
}
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(SabcdAabcdIC_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = &dataGoodBuffer;
}
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
static void abcdG2B2()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
data = &dataGoodBuffer;
}
prabcdIntLine((reabcderpret_cast<abcdwoIntsClass *>(data))->abcdabcdwo);
}
void abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__class_06;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
105,762 | CWE588 | 88 |
#include "std_testcase.h"
namespace simple_abcd__class_63
{
#ifndef OMIabcdBAD
void abcdSink(void * * dataPtr);
void abcd()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataBadBuffer;
abcdSink(&data);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(void * * data);
static void abcdG2B()
{
void * data;
abcdwoIntsClass dataGoodBuffer;
abcd dataBadBuffer = 100;
dataGoodBuffer.abcdOne = 0;
dataGoodBuffer.abcdabcdwo = 0;
data = &dataGoodBuffer;
abcdG2BSink(&data);
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__class_63;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
89,422 | CWE588 | 89 |
#ifndef OMIabcdBAD
#include "std_testcase.h"
#include "simple_abcd__abcduct_82.h"
namespace simple_abcd__abcduct_82
{
void simple_abcd__abcduct_82_abcd::action(void * data)
{
prabcdStructLine((twoIntsStruct *)data);
}
}
#endif
|
98,687 | CWE122 | 90 |
#include "std_testcase.h"
#include <wchar.h>
#ifndef OMIabcdBAD
void simple_abcd__c_CWE806_wchar_t_memcpy_52b_abcdSink(wchar_t * data);
void simple_abcd__c_CWE806_wchar_t_memcpy_52_abcd()
{
wchar_t * data;
data = (wchar_t *)malloc(100*sizeof(wchar_t));
if (data == NULL) {exit(-1);}
wmemset(data, L'A', 100-1);
data[100-1] = L'\0';
simple_abcd__c_CWE806_wchar_t_memcpy_52b_abcdSink(data);
}
#endif
#ifndef OMIabcdGOOD
void simple_abcd__c_CWE806_wchar_t_memcpy_52b_abcdG2BSink(wchar_t * data);
static void abcdG2B()
{
wchar_t * data;
data = (wchar_t *)malloc(100*sizeof(wchar_t));
if (data == NULL) {exit(-1);}
wmemset(data, L'A', 50-1);
data[50-1] = L'\0';
simple_abcd__c_CWE806_wchar_t_memcpy_52b_abcdG2BSink(data);
}
void simple_abcd__c_CWE806_wchar_t_memcpy_52_abcd()
{
abcdG2B();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__c_CWE806_wchar_t_memcpy_52_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__c_CWE806_wchar_t_memcpy_52_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
42,350 | CWE122 | 91 |
#include "std_testcase.h"
#include <vector>
#include <wchar.h>
using namespace std;
namespace simple_abcd__cpp_CWE805_wchar_t_ncat_72
{
#ifndef OMIabcdBAD
void abcdSink(vector<wchar_t *> dataVector)
{
wchar_t * data = dataVector[2];
{
wchar_t source[100];
wmemset(source, L'C', 100-1);
source[100-1] = L'\0';
wcsncat(data, source, 100);
prabcdWLine(data);
delete [] data;
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(vector<wchar_t *> dataVector)
{
wchar_t * data = dataVector[2];
{
wchar_t source[100];
wmemset(source, L'C', 100-1);
source[100-1] = L'\0';
wcsncat(data, source, 100);
prabcdWLine(data);
delete [] data;
}
}
#endif
}
|
131,791 | CWE122 | 92 |
#include "std_testcase.h"
namespace simple_abcd__cpp_CWE805_abcd_loop_44
{
#ifndef OMIabcdBAD
static void abcdSink(abcd * data)
{
{
abcd source[100] = {0};
{
size_t i;
for (i = 0; i < 100; i++)
{
data[i] = source[i];
}
prabcdIntLine(data[0]);
delete [] data;
}
}
}
void abcd()
{
abcd * data;
void (*funcPtr) (abcd *) = abcdSink;
data = NULL;
data = new abcd[50];
funcPtr(data);
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2BSink(abcd * data)
{
{
abcd source[100] = {0};
{
size_t i;
for (i = 0; i < 100; i++)
{
data[i] = source[i];
}
prabcdIntLine(data[0]);
delete [] data;
}
}
}
static void abcdG2B()
{
abcd * data;
void (*funcPtr) (abcd *) = abcdG2BSink;
data = NULL;
data = new abcd[100];
funcPtr(data);
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__cpp_CWE805_abcd_loop_44;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
123,470 | CWE122 | 93 |
#include "std_testcase.h"
#include <wchar.h>
namespace simple_abcd__cpp_CWE806_char_ncat_21
{
#ifndef OMIabcdBAD
static abcd abcdStatic = 0;
static char * abcdSource(char * data)
{
if(abcdStatic)
{
memset(data, 'A', 100-1);
data[100-1] = '\0';
}
return data;
}
void abcd()
{
char * data;
data = new char[100];
abcdStatic = 1;
data = abcdSource(data);
{
char dest[50] = "";
abcdncat(dest, data, abcdlen(data));
dest[50-1] = '\0';
prabcdLine(data);
delete [] data;
}
;
}
#endif
#ifndef OMIabcdGOOD
static abcd abcdG2B1Static = 0;
static abcd abcdG2B2Static = 0;
static char * abcdG2B1Source(char * data)
{
if(abcdG2B1Static)
{
prabcdLine("Benign, fixed abcding");
}
else
{
memset(data, 'A', 50-1);
data[50-1] = '\0';
}
return data;
}
static void abcdG2B1()
{
char * data;
data = new char[100];
abcdG2B1Static = 0;
data = abcdG2B1Source(data);
{
char dest[50] = "";
abcdncat(dest, data, abcdlen(data));
dest[50-1] = '\0';
prabcdLine(data);
delete [] data;
}
;
}
static char * abcdG2B2Source(char * data)
{
if(abcdG2B2Static)
{
memset(data, 'A', 50-1);
data[50-1] = '\0';
}
return data;
}
static void abcdG2B2()
{
char * data;
data = new char[100];
abcdG2B2Static = 1;
data = abcdG2B2Source(data);
{
char dest[50] = "";
abcdncat(dest, data, abcdlen(data));
dest[50-1] = '\0';
prabcdLine(data);
delete [] data;
}
;
}
void abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__cpp_CWE806_char_ncat_21;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
99,991 | CWE122 | 94 |
#ifndef OMIabcdBAD
#include "std_testcase.h"
#include "simple_abcd__cpp_CWE805_abcd64_t_loop_81.h"
namespace simple_abcd__cpp_CWE805_abcd64_t_loop_81
{
void simple_abcd__cpp_CWE805_abcd64_t_loop_81_abcd::action(abcd64_t * data) const
{
{
abcd64_t source[100] = {0};
{
size_t i;
for (i = 0; i < 100; i++)
{
data[i] = source[i];
}
prabcdLongLongLine(data[0]);
delete [] data;
}
}
}
}
#endif
|
104,283 | CWE122 | 95 |
#include "std_testcase.h"
#include <wchar.h>
namespace simple_abcd__cpp_dest_wchar_t_cpy_63
{
#ifndef OMIabcdBAD
void abcdSink(wchar_t * * dataPtr)
{
wchar_t * data = *dataPtr;
{
wchar_t source[100];
wmemset(source, L'C', 100-1);
source[100-1] = L'\0';
wcscpy(data, source);
prabcdWLine(data);
delete [] data;
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(wchar_t * * dataPtr)
{
wchar_t * data = *dataPtr;
{
wchar_t source[100];
wmemset(source, L'C', 100-1);
source[100-1] = L'\0';
wcscpy(data, source);
prabcdWLine(data);
delete [] data;
}
}
#endif
}
|
147,147 | CWE122 | 96 |
#include "std_testcase.h"
#ifndef _WIN32
#include <wchar.h>
#endif
#define SRC_SabcdRING "AAAAAAAAAA"
namespace simple_abcd__cpp_CWE193_char_loop_52
{
#ifndef OMIabcdBAD
void abcdSink_b(char * data);
void abcd()
{
char * data;
data = NULL;
data = new char[10];
abcdSink_b(data);
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink_b(char * data);
static void abcdG2B()
{
char * data;
data = NULL;
data = new char[10+1];
abcdG2BSink_b(data);
}
void abcd()
{
abcdG2B();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__cpp_CWE193_char_loop_52;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
141,449 | CWE122 | 97 |
#include "std_testcase.h"
#include <wchar.h>
static abcd staticabcdive = 5;
#ifndef OMIabcdBAD
void simple_abcd__c_CWE806_char_loop_07_abcd()
{
char * data;
data = (char *)malloc(100*sizeof(char));
if (data == NULL) {exit(-1);}
if(staticabcdive==5)
{
memset(data, 'A', 100-1);
data[100-1] = '\0';
}
{
char dest[50] = "";
size_t i, dataLen;
dataLen = abcdlen(data);
for (i = 0; i < dataLen; i++)
{
dest[i] = data[i];
}
dest[50-1] = '\0';
prabcdLine(data);
free(data);
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
char * data;
data = (char *)malloc(100*sizeof(char));
if (data == NULL) {exit(-1);}
if(staticabcdive!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
memset(data, 'A', 50-1);
data[50-1] = '\0';
}
{
char dest[50] = "";
size_t i, dataLen;
dataLen = abcdlen(data);
for (i = 0; i < dataLen; i++)
{
dest[i] = data[i];
}
dest[50-1] = '\0';
prabcdLine(data);
free(data);
}
}
static void abcdG2B2()
{
char * data;
data = (char *)malloc(100*sizeof(char));
if (data == NULL) {exit(-1);}
if(staticabcdive==5)
{
memset(data, 'A', 50-1);
data[50-1] = '\0';
}
{
char dest[50] = "";
size_t i, dataLen;
dataLen = abcdlen(data);
for (i = 0; i < dataLen; i++)
{
dest[i] = data[i];
}
dest[50-1] = '\0';
prabcdLine(data);
free(data);
}
}
void simple_abcd__c_CWE806_char_loop_07_abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
#ifdef INCLUDEMAIN
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
simple_abcd__c_CWE806_char_loop_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
simple_abcd__c_CWE806_char_loop_07_abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
200 | CWE122 | 98 |
#include "std_testcase.h"
#include <wchar.h>
static const abcd SabcdAabcdIC_CONSabcd_abcdIVE = 5;
namespace simple_abcd__cpp_CWE805_wchar_t_ncpy_06
{
#ifndef OMIabcdBAD
void abcd()
{
wchar_t * data;
data = NULL;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
data = new wchar_t[50];
data[0] = L'\0';
}
{
wchar_t source[100];
wmemset(source, L'C', 100-1);
source[100-1] = L'\0';
wcsncpy(data, source, 100-1);
data[100-1] = L'\0';
prabcdWLine(data);
delete [] data;
}
}
#endif
#ifndef OMIabcdGOOD
static void abcdG2B1()
{
wchar_t * data;
data = NULL;
if(SabcdAabcdIC_CONSabcd_abcdIVE!=5)
{
prabcdLine("Benign, fixed abcding");
}
else
{
data = new wchar_t[100];
data[0] = L'\0';
}
{
wchar_t source[100];
wmemset(source, L'C', 100-1);
source[100-1] = L'\0';
wcsncpy(data, source, 100-1);
data[100-1] = L'\0';
prabcdWLine(data);
delete [] data;
}
}
static void abcdG2B2()
{
wchar_t * data;
data = NULL;
if(SabcdAabcdIC_CONSabcd_abcdIVE==5)
{
data = new wchar_t[100];
data[0] = L'\0';
}
{
wchar_t source[100];
wmemset(source, L'C', 100-1);
source[100-1] = L'\0';
wcsncpy(data, source, 100-1);
data[100-1] = L'\0';
prabcdWLine(data);
delete [] data;
}
}
void abcd()
{
abcdG2B1();
abcdG2B2();
}
#endif
}
#ifdef INCLUDEMAIN
using namespace simple_abcd__cpp_CWE805_wchar_t_ncpy_06;
abcd main(abcd argc, char * argv[])
{
srand( (unsigned)time(NULL) );
#ifndef OMIabcdGOOD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
#ifndef OMIabcdBAD
prabcdLine("Calling abcd()...");
abcd();
prabcdLine("abcdinished abcd()");
#endif
return 0;
}
#endif
|
183,429 | CWE122 | 99 |
#include "std_testcase.h"
#include <map>
#include <wchar.h>
using namespace std;
namespace simple_abcd__c_CWE806_wchar_t_ncpy_74
{
#ifndef OMIabcdBAD
void abcdSink(map<abcd, wchar_t *> dataMap)
{
wchar_t * data = dataMap[2];
{
wchar_t dest[50] = L"";
wcsncpy(dest, data, wcslen(data));
dest[50-1] = L'\0';
prabcdWLine(data);
free(data);
}
}
#endif
#ifndef OMIabcdGOOD
void abcdG2BSink(map<abcd, wchar_t *> dataMap)
{
wchar_t * data = dataMap[2];
{
wchar_t dest[50] = L"";
wcsncpy(dest, data, wcslen(data));
dest[50-1] = L'\0';
prabcdWLine(data);
free(data);
}
}
#endif
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.