>> Hello. We've got an initialization vector.
We've got an algorithm,
and we've got our keys.
But it's probably worth mentioning
some desirable qualities of these things.
I don't have any desirable qualities of
an initialization vector written here.
But when we talked about that earlier,
we want our initialization vectors to be long enough.
That's true of keys as well.
Long enough means that based on the data,
we provide adequate security without training
too much performance or other costs.
That decision is based on risk management.
For our algorithms, we want the following.
First of all, confusion,
which means good, strong,
complex math in substitution.
That's what confusion is about.
If you look at my math functions,
they are not the most sophisticated functions,
so we need confusion.
Next is diffusion.
This means that interspersed with the ciphertext,
we had plain texts so that it's more
difficult to reverse and get an easy result.
It just adds to the complexity.
There's also something called chaining.
Sometimes you'll hear about cipher block chaining.
Chaining simply means output from
one function is used to input to the next.
But keep in mind that with the chaining algorithm,
you can have errors that are cascading or propagated
throughout because each output
from one function effects the next.
[NOISE] If we go back to our formula,
plain tags plus initialization factor
plus algorithm plus key equals ciphertext.
Let's say that I take the data of
the plain text and I chunk
the first block into 256 bit block,
and my ciphertext that gets
produced is the ciphertext for block 1.
Now, we chunk data into block 2.
But what is interesting is that block
2 is about to go through this same process.
But the initialization vector that is used on block 2
is actually the ciphertext
that was produced from block 1.
The output from the first block
is used as input for the second block.
That produces ciphertext from block
2 that uses input for block 3.
That is the chaining process.
Another desirable characteristic that
helps with the complexity is permutations.
This is where you put the data
through multiple permutations arounds.
DS, which we'll talk about
later scenes for data encryption standard.
It would chunk data into 64 bit blocks,
and each block would go through
the encryption process 16 times.
When we say they're 16 permutations with DES,
now DES was broken and it's
actually used a 56 bit key for its encryption process.
When that happened, we went to Triple DES.
Which Triple DES?
That means instead of 16 permutations,
each block went through 40 permutations
before it was encrypted,
we moved on to the next block.
In that case, Triple DES was a processing hog.
You wouldn't really want to use triple DES
normally because of the sheer
>> overhead of the processing.
>> That's why AES became much more
popular and so much less resource intensive.
But the number of permutations as the complexity.
You have to ask, how much is enough?
The answer is just enough.
Then the last bullet point here,
undesirable qualities of an algorithm is that we
want our algorithms to be
an open source and publicly known.
There's a big discussion in the privacy and
software development community about what is better,
open source or closed source?
Let's look at Unix versus Windows.
Unix is open source code.
You can look at the code and you can
manipulate it to work for your environment.
You can test it. There are no secrets.
Why? Well, this way the community can examine,
tear it apart, and put it back together stronger.
With more people working to create a better product,
the better the product will be.
Well, if you can look at Microsoft,
their philosophy is that if
other people can't see the code,
then they can't break the code.
But obviously people have
been able to break the Microsoft code.
It hasn't worked as well as they probably intended.
Their philosophy is one of
the security through obscurity.
If you can't see it, you can't break it.
But it doesn't work.
Our preference on this exam and
most other exams you might take is to have openness.
You should have a publicly known,
tried and true algorithm as your choice.
That is better than a proprietary secret algorithm
and is based on a principle
>> called Kerckhoff's principle.
>> I may not have had his name
spelled exactly right on the side.
But that's what the principle is called.
The principles as the algorithm he open.
The cryptography community will examine
your algorithm and make it better.
Now the desirable qualities
>> for keys are just as follows.
>> We want them to be long,
and that's just long enough.
We want them to be random,
and we want our keys to be secret.
If our algorithm is going to be open,
then the key has to be secret.
Once we have all this,
it's the basis upon which will build
everything that we'll do in the rest of the class.