End-Point Encryption

End-Point Encryption

We work on various encryption methodology. Our experts know various ways to implement mostly Asymmetric and Symmetric key cryptography. We have developed a modification of AES that is capable of standing against better and faster computing hacks. Among many products out there we are definitely different because our base technology used 2048 bits of encryption as opposed to 256 bits the current standard shows.

Typical Requirements and Product Capabilities

  • Usability
  • Manageability
  • Security
  • Platform Support and Portability

Technologies for Endpoint Encryption

  • Full-Disk Encryption Software
  • File/Folder Encryption
  • Self-Encrypting Drives
  • Secure USB Flash Drives
  • Encryption on Smartphones and Tablets

You can find the mathematical representation of the process in modular notation.

(ST-map-KT = M1) (mod n)
(KT* M1= M2) (mod n)
(M1* M2 = M3) (mod n)
(KT * M3 = M4) (mod n)
(M3 *M4 = M5) (mod n)

The 256 set of numbers are generated using a patent pending method to produce a cipher template seen below:

SKCJJU-256 Java Implementation/Technical manual

The Java programming language was used in order to produce a cross-platform executable
file. It works on Windows, Linux and Mac.
JDK (Java Development Kit) 6 and Netbeans 7.3+ are needed for building the source code.
Additional ‘Ant’ configuration was required to create a self-contained file with
dependencies.
SKCJJU-256 program relies on the following libraries:
• Google GSON 2.2.4: for marshalling/unmarshalling the email sending parameters.
• Google Guava 15.0: bidirectional hash table data structure was used for keeping
logarithmic complexity in several operations.
• Apache Commons Codec 1.8: base 64 utility class was used for encoding/decoding
data.

From a technical point of view, the program has the following workflow:
Encryption
1. The program loads the knight’s tour solutions file.
2. The program uses the first five tour solutions from the file in sequential order. We
store the solutions in a vector called KT. Elements are KT[0], KT[1], …, KT[4] (KT
is a vector of vectors).
3. Latin charset is provided to the algorithm. We are using the first 256 Unicode
characters, excluding ISO control codes while maintaining the new lines and
tabulation codes.
4. We created a vector ST of length 256 and fill it with our charset characters.
Elements are ST[0], ST[1], …, ST[255].
5. Password and message to encrypt are provided by the user.
6. 10 rounds of chained encryption are now performed, reversing the given password
between rounds (the password is used as given for first round). The given message
is used as input for the first round, round output is used as input for the next round
and so on.
7. For every round i (starting with i = 1) we produce a vector M given by the mapping
of ST and KT[k], where k = (i – 1) mod 5. For every 0 <= j < 256, M[j] =
ST[KT[k][j]].
8. Using vector M, we iterate the characters in the input message and we get the
ciphered string E, E[c] = M[(M.inverse[message[c]] + M.inverse[password[c mod
password.length]]) mod 256], where 0 <= c < message.length.
9. We output string E.

Decryption
1. Perform the steps 1 to 5 like in encryption.
2. 10 rounds of chained decryption are now performed, reversing the given password
between rounds. The given message is used as input for the first round, round
outputs are used as input for the next round and so on. In this case, password begins
in reverse.
3. For every round i (starting with i = 10 and descending) we produce a vector M
given by the mapping of ST and KT[k] (the tour solutions are the same in in
encryption but in reverse). For every 0 <= j < 256, M[j] = ST[KT[k][j]].
4. Using vector M, we iterate the characters in the input message and we get the
deciphered string D, D[c] = M[(M.inverse[message[c]] – M.inverse[password[c mod
password.length]]) mod 256], where 0 <= c < message.length.
5. We output string D.
Vector M is always a bijection when no characters are repeated in ST. M: [0..255] -> ST is
a function with inverse M.inverse: ST -> [0..255]. M is implemented as a bidirectional hash
table such that lookups in M and M.inverse are made in O(log n), where n is the size of M.
This way, multiple lookups are made in O(L log n) instead of O(L n) in an array based
approach, L is the number of lookups to perform. Non supported characters found in the
message are left as they appear in both encryption and decryption.

The above base technology is prevalent in one of our mobile product called LokDon.