[c++] basic_fuzzer.cpp

//WORK IN PROGRESS
//author : madconnor
//TODO:
    //functions
    //edit finish permutations
    //fix insert fx()
#include <iostream>
#include <string>
#include <vector>
#include <bitset>
#include "permutator.cpp"

using namespace std;

class basic_fuzzer : permutation {
    //instances
    permutator mutate;
    //binary size
private:
    int bin_mode *= &bin_64;
    int bin_4 = 4;
    int bin_8 = 8;
    int bin_16 = 16;
    int bin_32 = 32;
    int bin_64 = 64;
    //bitsets
    bitset<bin_4> 4_bit *= bitset< bin_4> &4_binary = 0x0;
    bitset<bin_8> 8_bit *= bitset< bin_8> &8_binary = 0x0;
    bitset<bin_16> 16_bit *= bitset<bin_16> &16_binary = 0x0;
    bitset<bin_32> 32_bit *= bitset<bin_32> &32_binary = 0x0;
    bitset<bin_64> 64_bit *= bitset<bin_64> &64_binary = 0x0;
    //bit buffer
    bitset<bin_4> 4_bit_buff *= bitset< bin_4> &4_binary_buffer = 0x0;
    bitset<bin_8> 8_bit_buff *= bitset< bin_8> &8_binary_buffer = 0x0;
    bitset<bin_16> 16_bit_buff *= bitset<bin_16> &16_binary_buffer = 0x0;
    bitset<bin_32> 32_bit_buff *= bitset<bin_32> &32_binary_buffer = 0x0;
    bitset<bin_64> 64_bit_buff *= bitset<bin_64> &64_binary_buffer = 0x0;
    //string values
    string _string = "";
    string v_string *= &mutate._string;
    vector<char> v_string *= &mutate.string_char;
    vector<string> fuzz_out *= &mutate.out;
    //functions
public:
    void input();
    void fuzzer();
    int bin_fuzz();
    void out_table();
    void execute();
    //bin fx()
private:
    int bin_generate();
    int bin_permutate();
    int bin_fx_permute(); // function combination
    int bin_reverse();
    int bin_prepend();
    int bin_append();
    int bin_insert();
    int bin_cut();
    int bin_replace();
};

void fuzzer() {

    v_string* = _string;
    mutate.convert();
    cout << "Fuzzer generates..." << endl;
    mutate.permutate();
    //add output result fx()
    cout << "Fuzzer finished..." << endl;
}
int bin_fuzz() {
}
void out_table() {
}
void execute() {
}
//bin ops
int basic_fuzzer::bin_fx_permutate(){

int fx_option

}

int basic_fuzzer::bin_generate() {
    for (int i = 0; i <= bin_mode * ^2; i++)
    {
        switch (bin_mode*) {
        case 4:
            bit_4++;
            cout << bit_4 << endl;
                break;
        case 8:
            bit_8++;
            cout << bit_8 << endl;
            break;
        case 16:
            bit_16++;
            cout << bit_16 << endl;
            break;
        case 32:
            bit_32++;
            cout << bit_32 << endl;
            break;
        case 64:
            bit_64++;
            cout << bit_64 << endl;
            break;
        default:
            cout << "Error: Binary mode invalid!" << endl;
            return 0;
            break;

        }
    }
}
int basic_fuzzer::bin_permutate() { // edit
    for (int i = 0; i <= bin_mode * ^2; i++)
    {
        switch (bin_mode*) {
        case 4:
            bit_4++;
            cout << bit_4 << endl;
            break;
        case 8:
            bit_8++;
            cout << bit_8 << endl;
            break;
        case 16:
            bit_16++;
            cout << bit_16 << endl;
            break;
        case 32:
            bit_32++;
            cout << bit_32 << endl;
            break;
        case 64:
            bit_64++;
            cout << bit_64 << endl;
            break;
        default:
            cout << "Error: Binary mode invalid!" << endl;
            return 0;
            break;

        }
    }
}
int basic_fuzzer::bin_reverse() {
    switch (bin_mode*) {
    case 4:
        bit_4++ ^ 0x0;
        cout << bit_4 << endl;
        break;
    case 8:
        bit_8++ ^ 0x0;
        cout << bit_8 << endl;
        break;
    case 16:
        bit_16++ ^ 0x0;
        cout << bit_16 << endl;
        break;
    case 32:
        bit_32 ^ 0x0;
        cout << bit_32 << endl;
        break;
    case 64:
        bit_64 ^ 0x0;
        cout << bit_64 << endl;
        break;
    default:
        cout << "Error: Binary mode invalid!" << endl;
        return 0;
        break;
    }
}
int basic_fuzzer::bin_prepend(bitwise<int size1> bit_1, bitwise<int size2> bit_2) {
    bitwise<size1 + size2> bit_result = 0x0;
    long numeric_result = 0;
    bit_result += bit_1;
    bit_1 >> size2;
    bit_result += bit_2;
    cout << bit_result << endl;
    numeric_result = bit_result;
    return numeric_result;
}
int basic_fuzzer::bin_append(bitwise<int size1> bit_1, bitwise<int size2> bit_2) {
    bitwise<size1 + size2> bit_result = 0x0;
    long int numeric_result = 0;
    bit_result += bit_1;
    bit_result += bit_2;
    cout << bit_result << endl;
    numeric_result = bit_result;
    return numeric_result;
}
int basic_fuzzer::bin_insert(int position, bitwise<int size1> bit_in, bitwise<int size2> bit_format) {
    bitwise<size1 + size2> bit_result = 0x0;
    bitwise<size1> front = 0x0; //fix later
    bitwise<size2 + size1> back = 0x0; // fix later
    bitwise<size1> front_and = 0x0 0xFFFFFFFFFFFFFFFFFFFF; //fix later
    bitwise<size2 + size1> back_and= 0x0 + 0xFFFFFFFFFFFFFFFFFFFF; // fix later
    front = bit_in & front_and;
    back = bit_in & back_and;
    bit_result += bit_in;
    bit_result >> size1;
    bit_result += front;
    bit_result += back;
    cout << bit_result << endl;
    long int numeric_result = bit_result;
    return numeric_result;
}
int basic_fuzzer::bin_cut(int begin, int end,bitwise<int size> cutter) { //fix later
    switch (bin_mode*) {
    case 4:
        bitwise<bin_4-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 8:
        bitwise<bin_8-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 16:
        bitwise<bin_16-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 32:
        bitwise<bin_32-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 64:
        bitwise<bin_64-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    default:
        cout << "Error: Binary mode invalid!" << endl;
        return 0;
        break;
    }
}
int basic_fuzzer::bin_replace(int position, bitwise<int size2> bit_replace) { //edit
    switch (bin_mode*) {
    case 4:
        bitwise<bin_4-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 8:
        bitwise<bin_8-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 16:
        bitwise<bin_16-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 32:
        bitwise<bin_32-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    case 64:
        bitwise<bin_64-begin> front;
        bitwise<end> back;
        int size_cut = end -begin;
        bitwise<size_cut> cut;
        cut += back;
        cut >> end;
        cut +=front
        break;
    default:
        cout << "Error: Binary mode invalid!" << endl;
        return 0;
        break;
    }

}