vimwiki/tech/LFSR.wiki

64 lines
2.0 KiB
Plaintext
Raw Normal View History

2021-12-15 19:00:01 +00:00
= Linear Feedback Shift Register =
A LFSR is set of rules to alter a set of bits. They are useful to psudeo random
number generators, and as key generators for stream ciphers.
All LFSRs are cyclical in nature, and after a set amount of time will repeat
2021-12-15 19:15:01 +00:00
back into themselves. The initial state of the bits in the LFSR is called the
2021-12-15 19:00:01 +00:00
seed.
2022-04-06 15:45:01 +00:00
The maximum period for a _n_ bit shift register is
2021-12-15 19:00:01 +00:00
2^n - 1
2021-12-15 19:45:01 +00:00
An LFSR can be generalized as a recurrence relationship where
- The preceding terms are not raised to a power
- There are no added constants
2021-12-15 19:00:01 +00:00
A *tap* is where a bit is read and fed back into itself.
2021-12-15 19:15:01 +00:00
2021-12-15 19:30:01 +00:00
== Reverse Engineering ==
An LFSR generates values based on a linear expression modulous 2, therefore we
can reverse engineer the state of the LFSR based on a sequence we are given.
This can be done using the Berlekamp-Massey algorithm.
2021-12-15 20:00:01 +00:00
So first we will start with a simpler version. If we have a sequence and we
know the number of bits in the LSFR, we can create a matrix of the values.
If S_{i} is the _i_ th value out of an LSFR, we can solve the following
Sa = x
Where S is a matrix of the outputted values formatted below
A has the coefficents of the LFSR
and x has values of the bit string, as formatted below.
{{{
Assume 4 bits
-- ---- -- -- --
| s0 s1 s2 s3 || a0 | | s4 |
| s1 s2 s3 s4 || a1 | = | s5 |
| s2 s3 s4 s5 || a2 | | s6 |
| s3 s4 s5 s6 || a3 | | s7 |
-- ---- -- -- --
}}}
Note that
- The S matrix is _n_ bits squared
- All other matrices are _n_ tall
- You need 2*n - 1 sample bits
Given this, we can find the coefficents by solving
a = S^-1 * x
Once we do this, it will give us all of the coefficents! Everywhere there
is a 1 a tap will be located there and all of these values are XORed and placed
onto the back of the register.
To make this the Berlekamp-Massey algorithm, we first start and assume the
number of bits _n_ is 1, check if it makes the right seuqnece, and if not we
increase _n_ and try again. That all there is to it!