FooSteg Maximum Obfuscation Brute Strength

 

 

 

When a FooSteg Data Image is In-Transit or resting In-Situ on media but kept apart from the FooSteg Source Image, the Maximum Obfuscation Brute Strength is effectively infinite, as both the Source Image and Data Image are required for any attempt to recover the Secret Data Blob.

Without the Source Image or Data Image(n), to access the Secret Data Blob via FooSteg, an adversary needs to calculate all binary per pixel combinations, due to the options that FooSteg provides to an end user.

FooSteg’s Maximum Obfuscation Brute Strength Calculations when the Source and Data Image are present is based on the following FooSteg options :

=> A Layer(n) implementation can be utilised on a single Source Image when the Secret Data Blob does not fit within a single layer of a Source Image :
Layer (1) = [ Source Image (+/- Binary Offset) Secret Data Blob(1) = Data Image(1) ]
Layer (2) = [ Data Image(1) (+/- Binary Offset) Secret Data Blob(2) = Data Image(2) ]
Layer (n) = [ Data Image(n-1) (+/- Binary Offset) Secret Data Blob(n) = Data Image(n) ]

The Number of Source and Data Images required to extract the Secret Data Blob can be represented as :
=> 2^n : n >= 1, n < ∞

=> In-Transit and In-Situ storage of the Source Image and Data Image(n) requires all the Data Image(n), in order to retrieve the complete Secret Data Blob.

=> Where the Source Image or all Data Image(n) are not available to an adversary, the adversary needs to calculate all binary per pixel combinations to extract the Secret Data Blob :

=> State^( Width x Height ) :
Width = Number of Pixels Wide
Height = Number of Pixels High
State = 27 Binary States per Pixel RGB Values

N = Skip RGB Value, Inserts a 0 into the Binary String ( Extract )
FooSteg -m and/or -M Value

∴ Minimum Image = 27^(10×10) => 1.3689147905e+143
∴ Maximum Image = 27^(10000×10000) => 2.6055459178e+143136376

=> Then the adversary needs to attempt to break any identified cypher text from the 2^n possible Secret Data Blobs identified.

=> FooSteg enables plausible deniability of the Secret Data Blob.

=> When utilised correctly, FooSteg obtains an In-Situ Storage Obfuscation Brute Strength equal to In-Transit of the Data Image.
=> FooCrypt by default uses 50 layers of OpenSSL’s AES-256 to enhance its Brute Strength as per The FooKey Method

Layer 1 : Password Characters : 256 = 2.8935810936531149e+507 Possible Combinations

Layer 1 : Password Characters : 512 = 8.37281154554675569e+1014 Possible Combinations

Layer 50 : Total Password Characters : 25600 = 4.18640577277337772e+1016 Possible Combinations

Layer 200 : Total Password Characters : 102400 = 1.67456230910935062e+1017 Possible Combinations

The Extract Permutation Brute Force Calculations are based on a single permutation length, and not the sum of all combinations of permutation lengths, hence the values below are considerably smaller than the actual Extract Permutation Brute Force Calculation Values.

A permutation is an arrangement of a set of objects in a specific order. In this case, we are talking about permutations of binary values in a pixel. For example, if we have a pixel with three binary values {0, 1, N}, without repetitions, the permutations of that pixel would be:

01N, 0N1, 10N, 1N0, N01, N10.

Repetitions refer to the number of times an item appears in a sequence or a set. In this case, repetitions of binary values in a sequence are allowed. For example, a sequence with the values 000 or 11N or NN0 would be allowed.

 

N = Skip RGB Value, Inserts a 0 into the Extract Binary String
FooSteg -m and/or -M Value

To find all possible permutations of binary values in a pixel, you can follow this step:

Take the number of binary values in the pixel (27) and raise it to the number of pixels.

∴ 27^(10×10) => 1.3689147905e+143
∴ 27^(10000×10000) => 2.6055459178e+143136376

Converting 27^(Width*Height) to a power of 2 using logarithmic properties

We can use the following formula to convert a number from base a to base b:

log_b(x) = log_a(x) / log_a(b)

Using this formula, we can convert 27 to base 2 as follows:

log2(27) = log10(27) / log10(2)

Then, we can use the power rule of logarithms to simplify the exponent ( 10 * 10 ) :

27^(1010) = (2^(log2(27)))^(1010) = 2^(log2(27) * 10*10)

Substituting the value of log2(27) from the above calculation :

27^(1010) = 2^(log10(27) / log10(2) * 1010)

∴ 27^(10×10) => 2e+(146.849)
∴ 27^(10000×10000) => 2e+(4.754888e+24)

 

‘FooCrypt makes a mountain out of a mole hill, and FooSteg hides the mountain in plain sight’

 

Protecting Data via An Effectively Infinite Brute Force & Obfuscation Solution(1)

∞