What is DES?

These days, security is the primary concern for everyone in IT. Given that $155 billion in expenditure on information security and risk management is expected to increase to $172 billion in 2022, according to Gartner, it must be. While there are many tools you can purchase to protect your data, encryption is one security tool that every computer user should be familiar with.

Why Encryption Is Useful?

Encryption is a technique for making data messages or files unreadable, guaranteeing that only a person with the proper authorization may access that data. Data is encrypted using sophisticated algorithms, and the same data is then decrypted using a key that is supplied by the message's sender. Information is kept secret and confidential by encryption while it is being stored or sent. Any unauthorized access will just reveal a disorganized collection of bytes.

You should be familiar with the following concepts related to encryption:

Algorithm

Algorithms, sometimes referred to as ciphers, are the guidelines or directions for the encryption procedure. The efficiency of the encryption depends on the key length, capabilities, and characteristics of the employed encryption method.

Decryption

Decryption is the process of turning unintelligible cipher text into understandable data.

Key

A random string of bits called an encryption key is used to encrypt and decode data. Longer keys are more difficult to break, and each key is different. Public keys typically have a length of 2048 bits, whereas private keys often have 128 or 256 bits.

Asymmetric and symmetric cryptographic key schemes are both available.

Symmetric Keys Systems

Everyone who accesses the data in a symmetric key system uses the same key. To maintain anonymity, encryption and decryption keys must also be kept a secret. While this is technically conceivable, it is impracticable to employ symmetric encryption for extensive commercial usage due to the need for securely distributing the keys to guarantee the right controls are in place.

Asymmetric Keys Systems

A public/private key system, sometimes referred to as an asymmetric key system, employs two keys. The private key is the only key that is kept a secret, although everyone else has access to the other key. The public key is what is known as. Due to the mathematical connection between the private and public keys, only the appropriate private key may decode data that has been encrypted with the help of the public key.

Practice of Encryption

Here's an illustration of how encryption functions using the email-friendly programme Pretty Good Privacy (PGP), often known as GnuPG or GPG for fans of open-source software. Let's say I want to message you privately. I use one of the programmes on the following list to encrypt it.

The advice is as follows:

wUwDPglyJu9LOnkBAf4vxSpQgQZltcz7LWwEquhdm5kSQIkQlZtfxtSTsmawq6gVH8SimlC3W6TDOhhL2FdgvdIC7sDv7G1Z7pCNzFLp0lgB9ACm8r5RZOBiN5ske9cBVjlVfgmQ9VpFzSwzLLODhCU7/2THg2iDrW3NGQZfz3SSWviwCe7GmNIvp5jEkGPCGcla4Fgdp/xuyewPk6NDlBewftLtHJVf=PAb3

The message is transformed into a garbled tangle of random characters after encryption. But if you have the key I provide you, you may unlock it and discover the message's original content.

Even if someone manages to access your network or system, encryption works to keep prying eyes out of your company, whether it's in transit like our hot dog party email or sitting on your hard drive.

The technology comes in a range of shapes and sizes, with key size and strength often indicating the biggest variations from one type to the next.

A short history of Triple DES and DES

The National Bureau of Standards, later known as NIST, recognized the need for a federal standard for encrypting sensitive, unclassified data in the early 1970s. Early suggestions for the new DES were rejected. Later, IBM Corporation presented a block cipher under the name of Lucifer in 1974. A modified version was accepted as a Federal Information Processing Standard in 1976 after discussion with the National Security Agency (NSA), and it was released on January 15, 1977, as FIPS PUB 46. It might be used to any unclassified data.

The key size was decreased from 128 bits to 56 bits in the authorized method, and substitution boxes (S-boxes) created under covert circumstances was the two most noticeable modifications between it and the original Lucifer cipher. The part of the algorithm that does substitution is called an S-box.

Many experts believed that the NSA had somehow incorporated a backdoor into the algorithm to enable the agency to decode data encrypted by DES without needing to know the encryption key and that the reduced key size rendered DES more vulnerable to brute-force assaults. Thirteen years later, it was found that the S-boxes were resistant to differential cryptanalysis, a 1990 widely disclosed attack. This implies that the NSA knew about this assault in 1977.

DES was immediately accepted despite these objections, which greatly increased the study and creation of encryption systems. In 1983, 1988, and 1993, it was confirmed as the norm. But as computers' processing capacity increased, DES became more open to brute-force assaults. Although there are over 72 quadrillion possible combinations in a 56-bit key space, this no longer offers the necessary levels of security. In 2005, the algorithm was discontinued.

The Triple DES standard, FIPS PUB 46-3, was released in 1999 to obviate the need to create a whole new cipher and to make replacing DES reasonably simple. It is currently suffering the same fate as its forerunner.

The Evolution of Cryptography

Security experts must continually come up with new plans and techniques to fend off cyber attacks since they are always changing. Even the National Institute of Standards and Technology (NIST) are examining how quantum cryptography will affect the development of encryption in the future. Watch this space for fresh information.

Modern classical, binary, transistor-based computers are not very efficient at doing some sorts of computations. Quantum computing methods aim to harness quantum phenomena to do so. If and when a quantum computer with sufficient computing capacity is created, it may execute algorithms that would be able to crack many of the encryption protocols we use to safeguard our data. Matt Scholl, director of the Computer Security Division at the National Institute of Standards and Technology (NIST), talks about how concerned we should be about this and what steps are being taken to lessen the risk that a future quantum computer poses to our data in this interview with Taking Measure.

Initial Permutation (IP)

The basic text is broken up into smaller, 64-bit-sized pieces. Before the first round, the IP is conducted. The transposition process' implementation is described in this step. For instance, the first bit is replaced by the 58th bit, the second bit by the 50th bit, and so on. Left Plain Text (LPT) and Right Plain Text (RPT) are the two equal 32-bit halves of the final 64-bit text.

Step 1: Key Transformation

We already know that the DES algorithm employs a 56-bit key, which is created by removing every bit from a 64-bit key's eighth place. A 48-bit key is produced in this stage. The 56-bit key is divided into two equal halves, with the number of rounds determining how many times the bits are circularly moved to the left.

As a result, the bits in the key are all rearranged. It is clear that some bits are lost during the shifting procedure, resulting in a 48-bit key. Compression permutation is the procedure in question.

Step 2: Expansion Permutation

Let's have a look at a 32-bit RPT that is produced at the IP step. It is increased from 32 to 48 bits in this stage. The RPT of 32-bit size is divided into 8 chunks of 4 bits each, with an additional 2 bits added to each chunk. The bits are then permuted among one another to produce 48-bit data. The 48-bit key acquired in step 1 and the 48-bit enlarged RPT are combined using an XOR function.

Triple DES Algorithm

Triple DES uses the DES cipher in triple and is a symmetric key-block cipher. It encrypts with key number one (k1), decrypts with key number two (k2), and then encrypts with key number three (k3).

Main Points

The DES algorithm had to be replaced by the NIST because, in light of the more powerful processing of modern computers, its 56-bit key lengths were insufficient. Because key size affects encryption strength, DES became obsolete due to continual advancements in computing technology. When the new encryption issues arose, 56-bit encryption was no longer sufficient.
The fact that DES is no longer the NIST federal standard should not be taken to imply that it is no longer in use. Even though Triple DES is still in use today, it is regarded as an old encryption algorithm. Keep in mind that starting in 2024, NIST intends to outlaw all variations of Triple-DES.

DES Algorithm Procedure

In plain English, DES transforms 64-bit plain text into a 64-bit cipher text. The same key is also utilized to decode the text because asymmetric methods are being employed.

The following steps comprise the algorithmic process:

The 64-bit plain text block is first sent to an initial permutation (IP) function to start the process.
The plain text is subsequently subjected to the initial permutation (IP).
The Left Plain Text (LPT) and Right Plain Text (RPT) portions of the permuted block are then created by the initial permutation (IP).
There are 16 rounds of encryption for each LPT and RPT.
Finally, the LPT and RPT are reunited, and the newly combined block is subjected to a Final Permutation (FP).
This procedure provides the necessary 64-bit ciphertext as a result.

The phase of the encryption process (step 4, above) is further divided into the following five stages:

Key transition
Expansion permutation
XOR and swap
S-Box
P-Box permutations

We employ the same procedure for decryption and arrange the 16 round keys in the other direction.

Let's study about the several ways that DES might operate next so that we can better comprehend what it is.

Modes of Operation for DES

There are five main modes of operation available to experts utilizing DES.

(ECB) Electronic Codebook. Each 64-bit block is separately encrypted and decrypted.
CBC, or cypher block chaining. Each 64-bit block employs an Initialization Vector (IV) and is dependent on the previous one.
CFB, or Cypher Feedback. The previous unit of cipher text serves as the input for the encryption algorithm, which generates pseudorandom output that is then XORed with the plaintext to create the following unit of cipher text.
OFB (Output Feedback). similar to CFB, but where the input for the encryption technique is the result of the previous DES
CTR, or counter. An encrypted counter is XORed with each plaintext piece. Following that, the counter gets increased for each additional block.

We'll then deepen our understanding of DES by examining its implementation and testing.

Testing and Implementation of DES

A security provider is required for DES deployment. Even if there are several suppliers to choose from, choose one is the crucial first step in deployment. Your choice could be influenced by the language you're working in, such as MATLAB, Java, Python, or C.

Once you've selected a provider, you must pick whether to use a plaintext or byte array to construct a key that will be randomly created by the Key Generator.

To make sure the encryption is used correctly, it is also crucial to test it.

Below is the example of DES in python:

# Python3 code for the above approach
# Hexadecimal to binary conversion 
def hex2bin(s):
    mp = {'0': "0000",
          '1': "0001",
          '2': "0010",
          '3': "0011",
          '4': "0100",
          '5': "0101",
          '6': "0110",
          '7': "0111",
          '8': "1000",
          '9': "1001",
          'A': "1010",
          'B': "1011",
          'C': "1100",
          'D': "1101",
          'E': "1110",
          'F': "1111"}
    bin = ""
    for i in range(len(s)):
        bin = bin + mp[s[i]]
    return bin
 
# Binary to hexadecimal conversion
 
 
def bin2hex(s):
    mp = {"0000": '0',
          "0001": '1',
          "0010": '2',
          "0011": '3',
          "0100": '4',
          "0101": '5',
          "0110": '6',
          "0111": '7',
          "1000": '8',
          "1001": '9',
          "1010": 'A',
          "1011": 'B',
          "1100": 'C',
          "1101": 'D',
          "1110": 'E',
          "1111": 'F'}
    hex = ""
    for i in range(0, len(s), 4):
        ch = ""
        ch = ch + s[i]
        ch = ch + s[i + 1]
        ch = ch + s[i + 2]
        ch = ch + s[i + 3]
        hex = hex + mp[ch]
 
    return hex
 
# Binary to decimal conversion
 
 
def bin2dec(binary):
 
    binary1 = binary
    decimal, i, n = 0, 0, 0
    while(binary != 0):
        dec = binary % 10
        decimal = decimal + dec * pow(2, i)
        binary = binary//10
        i += 1
    return decimal
 
# Decimal to binary conversion
 
 
def dec2bin(num):
    res = bin(num).replace("0b", "")
    if(len(res) % 4 != 0):
        div = len(res) / 4
        div = int(div)
        counter = (4 * (div + 1)) - len(res)
        for i in range(0, counter):
            res = '0' + res
    return res
 
# Permute function to rearrange the bits
 
 
def permute(k, arr, n):
    permutation = ""
    for i in range(0, n):
        permutation = permutation + k[arr[i] - 1]
    return permutation
 
# shifting the bits towards left by nth shifts
 
 
def shift_left(k, nth_shifts):
    s = ""
    for i in range(nth_shifts):
        for j in range(1, len(k)):
            s = s + k[j]
        s = s + k[0]
        k = s
        s = ""
    return k
 
# calculating xow of two strings of binary number a and b
 
 
def xor(a, b):
    ans = ""
    for i in range(len(a)):
        if a[i] == b[i]:
            ans = ans + "0"
        else:
            ans = ans + "1"
    return ans
 
 
# Table of Position of 64 bits at initial level: Initial Permutation Table
initial_perm = [58, 50, 42, 34, 26, 18, 10, 2,
                60, 52, 44, 36, 28, 20, 12, 4,
                62, 54, 46, 38, 30, 22, 14, 6,
                64, 56, 48, 40, 32, 24, 16, 8,
                57, 49, 41, 33, 25, 17, 9, 1,
                59, 51, 43, 35, 27, 19, 11, 3,
                61, 53, 45, 37, 29, 21, 13, 5,
                63, 55, 47, 39, 31, 23, 15, 7]
 
# Expansion D-box Table
exp_d = [32, 1, 2, 3, 4, 5, 4, 5,
         6, 7, 8, 9, 8, 9, 10, 11,
         12, 13, 12, 13, 14, 15, 16, 17,
         16, 17, 18, 19, 20, 21, 20, 21,
         22, 23, 24, 25, 24, 25, 26, 27,
         28, 29, 28, 29, 30, 31, 32, 1]
 
# Straight Permutation Table
per = [16,  7, 20, 21,
       29, 12, 28, 17,
       1, 15, 23, 26,
       5, 18, 31, 10,
       2,  8, 24, 14,
       32, 27,  3,  9,
       19, 13, 30,  6,
       22, 11,  4, 25]
 
# S-box Table
sbox = [[[14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7],
         [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8],
         [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0],
         [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13]],
 
        [[15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10],
         [3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5],
         [0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15],
         [13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9]],
 
        [[10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8],
         [13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1],
         [13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7],
         [1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12]],
 
        [[7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15],
         [13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9],
         [10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4],
         [3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14]],
 
        [[2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9],
         [14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6],
         [4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14],
         [11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3]],
 
        [[12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11],
         [10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8],
         [9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6],
         [4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13]],
 
        [[4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1],
         [13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6],
         [1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2],
         [6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12]],
 
        [[13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7],
         [1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2],
         [7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8],
         [2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11]]]
 
# Final Permutation Table
final_perm = [40, 8, 48, 16, 56, 24, 64, 32,
              39, 7, 47, 15, 55, 23, 63, 31,
              38, 6, 46, 14, 54, 22, 62, 30,
              37, 5, 45, 13, 53, 21, 61, 29,
              36, 4, 44, 12, 52, 20, 60, 28,
              35, 3, 43, 11, 51, 19, 59, 27,
              34, 2, 42, 10, 50, 18, 58, 26,
              33, 1, 41, 9, 49, 17, 57, 25]
 
 
def encrypt(pt, rkb, rk):
    pt = hex2bin(pt)
 
    # Initial Permutation
    pt = permute(pt, initial_perm, 64)
    print("After initial permutation", bin2hex(pt))
 
    # Splitting
    left = pt[0:32]
    right = pt[32:64]
    for i in range(0, 16):
        #  Expansion D-box: Expanding the 32 bits data into 48 bits
        right_expanded = permute(right, exp_d, 48)
 
        # XOR RoundKey[i] and right_expanded
        xor_x = xor(right_expanded, rkb[i])
 
        # S-boxex: substituting the value from s-box table by calculating row and column
        sbox_str = ""
        for j in range(0, 8):
            row = bin2dec(int(xor_x[j * 6] + xor_x[j * 6 + 5]))
            col = bin2dec(
                int(xor_x[j * 6 + 1] + xor_x[j * 6 + 2] + xor_x[j * 6 + 3] + xor_x[j * 6 + 4]))
            val = sbox[j][row][col]
            sbox_str = sbox_str + dec2bin(val)
 
        # Straight D-box: After substituting rearranging the bits
        sbox_str = permute(sbox_str, per, 32)
 
        # XOR left and sbox_str
        result = xor(left, sbox_str)
        left = result
 
        # Swapper
        if(i != 15):
            left, right = right, left
        print("Round ", i + 1, " ", bin2hex(left),
              " ", bin2hex(right), " ", rk[i])
 
    # Combination
    combine = left + right
 
    # Final permutation: final rearranging of bits to get cipher text
    cipher_text = permute(combine, final_perm, 64)
    return cipher_text
 
 
pt = "123456ABCD132536"
key = "AABB09182736CCDD"
 
# Key generation
# --hex to binary
key = hex2bin(key)
 
# --parity bit drop table
keyp = [57, 49, 41, 33, 25, 17, 9,
        1, 58, 50, 42, 34, 26, 18,
        10, 2, 59, 51, 43, 35, 27,
        19, 11, 3, 60, 52, 44, 36,
        63, 55, 47, 39, 31, 23, 15,
        7, 62, 54, 46, 38, 30, 22,
        14, 6, 61, 53, 45, 37, 29,
        21, 13, 5, 28, 20, 12, 4]
 
# getting 56 bit key from 64 bit using the parity bits
key = permute(key, keyp, 56)
 
# Number of bit shifts
shift_table = [1, 1, 2, 2,
               2, 2, 2, 2,
               1, 2, 2, 2,
               2, 2, 2, 1]
 
# Key- Compression Table : Compression of key from 56 bits to 48 bits
key_comp = [14, 17, 11, 24, 1, 5,
            3, 28, 15, 6, 21, 10,
            23, 19, 12, 4, 26, 8,
            16, 7, 27, 20, 13, 2,
            41, 52, 31, 37, 47, 55,
            30, 40, 51, 45, 33, 48,
            44, 49, 39, 56, 34, 53,
            46, 42, 50, 36, 29, 32]
 
# Splitting
left = key[0:28]    # rkb for RoundKeys in binary
right = key[28:56]  # rk for RoundKeys in hexadecimal
 
rkb = []
rk = []
for i in range(0, 16):
    # Shifting the bits by nth shifts by checking from shift table
    left = shift_left(left, shift_table[i])
    right = shift_left(right, shift_table[i])
 
    # Combination of left and right string
    combine_str = left + right
 
    # Compression of key from 56 to 48 bits
    round_key = permute(combine_str, key_comp, 48)
 
    rkb.append(round_key)
    rk.append(bin2hex(round_key))
 
print("Encryption")
cipher_text = bin2hex(encrypt(pt, rkb, rk))
print("Cipher Text : ", cipher_text)
 
print("Decryption")
rkb_rev = rkb[::-1]
rk_rev = rk[::-1]
text = bin2hex(encrypt(cipher_text, rkb_rev, rk_rev))
print("Plain Text : ", text)

Output:

...60AF7CA5
Round 12 FF3C485F 22A5963B C2C1E96A4BF3
Round 13 22A5963B 387CCDAA 99C31397C91F
Round 14 387CCDAA BD2DD2AB 251B8BC717D0
Round 15 BD2DD2AB CF26B472 3330C5D9A36D
Round 16 19BA9212 CF26B472 181C5D75C66D

Cipher Text: C0B7A8D05F3A829C

Decryption

After initial permutation: 19BA9212CF26B472
After splitting: L0=19BA9212 R0=CF26B472

Round 1 CF26B472 BD2DD2AB 181C5D75C66D
Round 2 BD2DD2AB 387CCDAA 3330C5D9A36D
Round 3 387CCDAA 22A5963B 251B8BC717D0
Round 4 22A5963B FF3C485F 99C31397C91F
Round 5 FF3C485F 6CA6CB20 C2C1E96A4BF3
Round 6 6CA6CB20 10AF9D37 6D5560AF7CA5
Round 7 10AF9D37 308BEE97 02765708B5BF
Round 8 308BEE97 A9FC20A3 84BB4473DCCC
Round 9 A9FC20A3 2E8F9C65 34F822F0C66D
Round 10 2E8F9C65 A15A4B87 708AD2DDB3C0
Round 11 A15A4B87 236779C2 C1948E87475E
Round 12 236779C2 B8089591 69A629FEC913
Round 13 B8089591 4A1210F6 DA2D032B6EE3
Round 14 4A1210F6 5A78E394 06EDA4ACF5B5
Round 15 5A78E394 18CA18AD 4568581ABCCE
Round 16 14A7D678 18CA18AD 194CD072DE8C

Plain Text: 123456ABCD132536
Output: 

Encryption :

After initial permutation: 14A7D67818CA18AD
After splitting: L0=14A7D678 R0=18CA18AD

Round 1 18CA18AD 5A78E394 194CD072DE8C
Round 2 5A78E394 4A1210F6 4568581ABCCE
Round 3 4A1210F6 B8089591 06EDA4ACF5B5
Round 4 B8089591 236779C2 DA2D032B6EE3
Round 5 236779C2 A15A4B87 69A629FEC913
Round 6 A15A4B87 2E8F9C65 C1948E87475E
Round 7 2E8F9C65 A9FC20A3 708AD2DDB3C0
Round 8 A9FC20A3 308BEE97 34F822F0C66D
Round 9 308BEE97 10AF9D37 84BB4473DCCC
Round 10 10AF9D37 6CA6CB20 02765708B5BF
Round 11 6CA6CB20 FF3C485F 6D5560AF7CA5
Round 12 FF3C485F 22A5963B C2C1E96A4BF3
Round 13 22A5963B 387CCDAA 99C31397C91F
Round 14 387CCDAA BD2DD2AB 251B8BC717D0
Round 15 BD2DD2AB CF26B472 3330C5D9A36D
Round 16 19BA9212 CF26B472 181C5D75C66D

Cipher Text : C0B7A8D05F3A829C

Decryption

After initial permutation: 19BA9212CF26B472
After splitting: L0=19BA9212 R0=CF26B472

Round 1 CF26B472 BD2DD2AB 181C5D75C66D
Round 2 BD2DD2AB 387CCDAA 3330C5D9A36D
Round 3 387CCDAA 22A5963B 251B8BC717D0
Round 4 22A5963B FF3C485F 99C31397C91F
Round 5 FF3C485F 6CA6CB20 C2C1E96A4BF3
Round 6 6CA6CB20 10AF9D37 6D5560AF7CA5
Round 7 10AF9D37 308BEE97 02765708B5BF
Round 8 308BEE97 A9FC20A3 84BB4473DCCC
Round 9 A9FC20A3 2E8F9C65 34F822F0C66D
Round 10 2E8F9C65 A15A4B87 708AD2DDB3C0
Round 11 A15A4B87 236779C2 C1948E87475E
Round 12 236779C2 B8089591 69A629FEC913
Round 13 B8089591 4A1210F6 DA2D032B6EE3
Round 14 4A1210F6 5A78E394 06EDA4ACF5B5
Round 15 5A78E394 18CA18AD 4568581ABCCE
Round 16 14A7D678 18CA18AD 194CD072DE8C

Plain Text: 123456ABCD132536

Next TopicEmerging Cyber Security threats

← prev next →