Elvis Wiki - User contributions [en]

CyberChef

2024-12-17T18:23:24Z

PSimetzberger:

Cyberchef is a tool that is used to execute various encoding, encryption, data processing and transformation tasks. It was created by the GCHQ (Government Communications Headquarters) and is also known as the "Cyber Swiss Army Knife", because of its wide variety of operations. A link to a online version can be found in the Readme file in the official github repository <ref name="Cyberchef">Cyberchef. Available: https://github.com/gchq/CyberChef. Accessed: Oct. 10, 2024</ref>.

== Installation ==
The whole tool can be downloaded using docker. The following command pulls the latest version of the program and starts a container. The webpage can then be seen on the localhost on port 8080 on the browser.

* docker run -it -p 8080:80 ghcr.io/gchq/cyberchef:latest

Alternatively, the program can be build directly. For this the repository needs to be cloned and within the folder the following commands need to be executed.
* docker build --tag cyberchef --ulimit nofile=10000 .
* docker run -it -p 8080:80 cyberchef

== How to use ==

The webpage has 4 important parts.The first one is the Operations tab. There is a list of all functions that can be executed. Double clicking on a function adds it to the second tab called recipe. Alternatively, the function can be dragged into the recipe tab This tab contains a list of all functions that will be executed. The input will go through all functions from top to bottom and the output of the function above will be the input of the function below. The third tab is for the input. Here the user can paste whatever input they want to process. The last tab is for the output. The result of the last function will be posted here. The tool also allows to save and load recipes.
[[File:Cyberchef.png|500px|thumb|center|Cyberchef <ref name="BOB">Cyberchef Webpage Available: https://gchq.github.io/CyberChef/ Accessed: Oct. 10, 2024</ref>]]

== References ==

[[Category:Basic]]

File:Cyberchef.png

2024-12-17T18:17:05Z

PSimetzberger:

SHA-3

2024-12-17T18:10:51Z

PSimetzberger:

SHA-3 is a cryptographic hash function and the newest addition to the SHA family. Guido Bertoni, Joan Daemen, Michael Peeters and Gilles Van Assche created the algorithm with the name Keccak. In 2012 Keccak won the american SHA-3 contest organized by NIST. On the 5th of August 2015 it was standardised, allowing for an alternative to SHA-2 (which is still considered save). <ref name="NIST_HASH"> NIST Documentation, Available: https://csrc.nist.gov/projects/hash-functions, Accessed: Oct. 10, 2024</ref>

== General information ==

=== Hashing Algorithm ===
A hashing algorithm is a mathenmatical function that converts an input to a fixed-size output which is often refered as hash value or digest. Hashing is a crucial part of cyber security and widely used in data integrity, verification, cryptography and more.

Hashing algorithms are deterministic, meaning that the same input will always result in the same output. Another characteristic is that a small change in the input leads to significant changes in the hash. Further characteristics can be found under Hashing goals.

=== Hashing goals ===

SHA-3 like every other hashing algorithm pursues the same 5 goals.
* Compression: The algorithm must produce the same fixed length output regardless of the length of the input
* Efficient: It must be fast to calculate the function as it will be calculated a lot.
* Pre-image resistance: Knowing the algorithm and output it should be infeasable to calculate the input
* 2nd Pre-image resistance: Given an input and output of the algorithm, it should be infeasable to calculate a second input resulting in the same output
* Collision resistance: Finding 2 inputs giving the same output should be implausible

=== Hashing Process ===
Algorithms follow a simple 3 step process to calculate the hash.
* Pre-processing: The goal is to get the input in a way the algorithm can handle. This includes processes like padding or splitting the input into blocks
* Initialization: Initial variables and constants are set
* Execution: The actual hashing algorithm is executed

== Calculation ==

=== Sponge construction ===
The Keccak algorithm is a so called sponge construction. It is called that, because it "absorbs" the input and then "squeezes" out the output.

The algorithm uses a 1600-bit array called state which it uses for the caluclations and which will contain the output afterwards. It is divided into 2 parts. The first one is called rate (r) and it will absorb the input. The second part is called capacity (c) and its only function is to make the algorithm more secure.

After the state is initialized, the input message is divided into parts that are as long as the rate. If needed, the last input block will be padded by adding a 1 and then fill it up with 0 to the needed length.

[[File:SpongeConstruction.svg.png|500px|thumb|right|Sponge Construction model <ref name="BOB">Sponge Construction, Available: https://de.wikipedia.org/wiki/Datei:SpongeConstruction.svg. Accessed: Oct. 01, 2024</ref>]]

The first input block is now XORed with the state. Afterwards the Keccak algorithm will be used on the state. Then the next block is XORed and the whole process repeats until all chunks are absorbed into the algorithm

Lastly the output is "squeezed" out. The first r bits of the state are taken as the hash value. If the output length is larger than r, the Keccak algorithm will be used again on the state and the next r bits are extraced. This process can repeat until the output length is reached. <ref name="NIST_Fips"> NIST Documentation, Available: https://csrc.nist.gov/pubs/fips/202/final, Accessed: Oct. 10, 2024</ref>

=== Keccak-p permutation ===
This is the core component of the SHA-3 algorithm. It contains 5 different operations which are executed in order on the state array. To ensure the hashing goals, multiple rounds of the permutation are done in one call of the algorithm. The default for SHA-3 are 24 rounds, meaning that a single call will execute the Keccak-p permutation 24 times before it returns the state. Because of this, the number of rounds is usually an additional input parameter.
The state is usually divided into a 5x5 matrix with 64 bits in each position.
[[File:Sha3.png|150px|thumb|right|Keccak-p permutation sequence<ref> Keccak-p permutation sequence </ref>]]

* Step 1, Theta: XOR each bit with a representative value derived from neighboring columns
* Step 2, Rho: Rotates each lane's bits by a specific offset based on its position
* Step 3, Pi: Rearranges the positions of the lanes
* Step 4, Chi: Applies a non-linear transformation to each row using bitwise operations
* Step 5, Iota: XOR with round-specific constants to prevent symmetry
<ref name="NIST_Fips"/>

== References ==

[[Category:Basic]]

SHA-3

2024-12-17T18:05:13Z

PSimetzberger:

SHA-3 is a cryptographic hash function and the newest addition to the SHA family. Guido Bertoni, Joan Daemen, Michael Peeters and Gilles Van Assche created the algorithm with the name Keccak. In 2012 Keccak won the american SHA-3 contest organized by NIST. On the 5th of August 2015 it was standardised, allowing for an alternative to SHA-2 (which is still considered save). <ref name="NIST_HASH"> NIST Documentation, Available: https://csrc.nist.gov/projects/hash-functions, Accessed: Oct. 10, 2024</ref>

== General information ==

=== Hashing Algorithm ===
A hashing algorithm is a mathenmatical function that converts an input to a fixed-size output which is often refered as hash value or digest. Hashing is a crucial part of cyber security and widely used in data integrity, verification, cryptography and more.

Hashing algorithms are deterministic, meaning that the same input will always result in the same output. Another characteristic is that a small change in the input leads to significant changes in the hash. Further characteristics can be found under Hashing goals.

=== Hashing goals ===

SHA-3 like every other hashing algorithm pursues the same 5 goals.
* Compression: The algorithm must produce the same fixed length output regardless of the length of the input
* Efficient: It must be fast to calculate the function as it will be calculated a lot.
* Pre-image resistance: Knowing the algorithm and output it should be infeasable to calculate the input
* 2nd Pre-image resistance: Given an input and output of the algorithm, it should be infeasable to calculate a second input resulting in the same output
* Collision resistance: Finding 2 inputs giving the same output should be implausible

=== Hashing Process ===
Algorithms follow a simple 3 step process to calculate the hash.
* Pre-processing: The goal is to get the input in a way the algorithm can handle. This includes processes like padding or splitting the input into blocks
* Initialization: Initial variables and constants are set
* Execution: The actual hashing algorithm is executed

== Calculation ==

=== Sponge construction ===
The Keccak algorithm is a so called sponge construction. It is called that, because it "absorbs" the input and then "squeezes" out the output.

The algorithm uses a 1600-bit array called state which it uses for the caluclations and which will contain the output afterwards. It is divided into 2 parts. The first one is called rate (r) and it will absorb the input. The second part is called capacity (c) and its only function is to make the algorithm more secure.

After the state is initialized, the input message is divided into parts that are as long as the rate. If needed, the last input block will be padded by adding a 1 and then fill it up with 0 to the needed length.

[[File:SpongeConstruction.svg.png|500px|right|Sponge Construction model <ref name="BOB">Sponge Construction, Available: https://de.wikipedia.org/wiki/Datei:SpongeConstruction.svg. Accessed: Oct. 01, 2024</ref>]]

The first input block is now XORed with the state. Afterwards the Keccak algorithm will be used on the state. Then the next block is XORed and the whole process repeats until all chunks are absorbed into the algorithm

Lastly the output is "squeezed" out. The first r bits of the state are taken as the hash value. If the output length is larger than r, the Keccak algorithm will be used again on the state and the next r bits are extraced. This process can repeat until the output length is reached. <ref name="NIST_Fips"> NIST Documentation, Available: https://csrc.nist.gov/pubs/fips/202/final, Accessed: Oct. 10, 2024</ref>

=== Keccak-p permutation ===
This is the core component of the SHA-3 algorithm. It contains 5 different operations which are executed in order on the state array. To ensure the hashing goals, multiple rounds of the permutation are done in one call of the algorithm. The default for SHA-3 are 24 rounds, meaning that a single call will execute the Keccak-p permutation 24 times before it returns the state. Because of this, the number of rounds is usually an additional input parameter.
The state is usually divided into a 5x5 matrix with 64 bits in each position.

[[File:Sha3.png|190px|right|<ref> Keccak-p permutation sequence </ref>]]

* Step 1, Theta: XOR each bit with a representative value derived from neighboring columns
* Step 2, Rho: Rotates each lane's bits by a specific offset based on its position
* Step 3, Pi: Rearranges the positions of the lanes
* Step 4, Chi: Applies a non-linear transformation to each row using bitwise operations
* Step 5, Iota: XOR with round-specific constants to prevent symmetry
<ref name="NIST_Fips"/>

== References ==

[[Category:Basic]]

SHA-3

2024-12-17T18:03:56Z

PSimetzberger:

SHA-3 is a cryptographic hash function and the newest addition to the SHA family. Guido Bertoni, Joan Daemen, Michael Peeters and Gilles Van Assche created the algorithm with the name Keccak. In 2012 Keccak won the american SHA-3 contest organized by NIST. On the 5th of August 2015 it was standardised, allowing for an alternative to SHA-2 (which is still considered save). <ref name="NIST_HASH"> NIST Documentation, Available: https://csrc.nist.gov/projects/hash-functions, Accessed: Oct. 10, 2024</ref>

== General information ==

=== Hashing Algorithm ===
A hashing algorithm is a mathenmatical function that converts an input to a fixed-size output which is often refered as hash value or digest. Hashing is a crucial part of cyber security and widely used in data integrity, verification, cryptography and more.

Hashing algorithms are deterministic, meaning that the same input will always result in the same output. Another characteristic is that a small change in the input leads to significant changes in the hash. Further characteristics can be found under Hashing goals.

=== Hashing goals ===

SHA-3 like every other hashing algorithm pursues the same 5 goals.
* Compression: The algorithm must produce the same fixed length output regardless of the length of the input
* Efficient: It must be fast to calculate the function as it will be calculated a lot.
* Pre-image resistance: Knowing the algorithm and output it should be infeasable to calculate the input
* 2nd Pre-image resistance: Given an input and output of the algorithm, it should be infeasable to calculate a second input resulting in the same output
* Collision resistance: Finding 2 inputs giving the same output should be implausible

=== Hashing Process ===
Algorithms follow a simple 3 step process to calculate the hash.
* Pre-processing: The goal is to get the input in a way the algorithm can handle. This includes processes like padding or splitting the input into blocks
* Initialization: Initial variables and constants are set
* Execution: The actual hashing algorithm is executed

== Calculation ==

=== Sponge construction ===
The Keccak algorithm is a so called sponge construction. It is called that, because it "absorbs" the input and then "squeezes" out the output.

The algorithm uses a 1600-bit array called state which it uses for the caluclations and which will contain the output afterwards. It is divided into 2 parts. The first one is called rate (r) and it will absorb the input. The second part is called capacity (c) and its only function is to make the algorithm more secure.

After the state is initialized, the input message is divided into parts that are as long as the rate. If needed, the last input block will be padded by adding a 1 and then fill it up with 0 to the needed length.

[[File:SpongeConstruction.svg.png|500px|right|Sponge Construction model <ref name="BOB">Sponge Construction, Available: https://de.wikipedia.org/wiki/Datei:SpongeConstruction.svg. Accessed: Oct. 01, 2024</ref>]]

The first input block is now XORed with the state. Afterwards the Keccak algorithm will be used on the state. Then the next block is XORed and the whole process repeats until all chunks are absorbed into the algorithm

Lastly the output is "squeezed" out. The first r bits of the state are taken as the hash value. If the output length is larger than r, the Keccak algorithm will be used again on the state and the next r bits are extraced. This process can repeat until the output length is reached. <ref name="NIST_Fips"> NIST Documentation, Available: https://csrc.nist.gov/pubs/fips/202/final, Accessed: Oct. 10, 2024</ref>

=== Keccak-p permutation ===
This is the core component of the SHA-3 algorithm. It contains 5 different operations which are executed in order on the state array. To ensure the hashing goals, multiple rounds of the permutation are done in one call of the algorithm. The default for SHA-3 are 24 rounds, meaning that a single call will execute the Keccak-p permutation 24 times before it returns the state. Because of this, the number of rounds is usually an additional input parameter.
The state is usually divided into a 5x5 matrix with 64 bits in each position.

[[File:Sha3.png|190px|right|Keccak-p permutation sequence]]

* Step 1, Theta: XOR each bit with a representative value derived from neighboring columns
* Step 2, Rho: Rotates each lane's bits by a specific offset based on its position
* Step 3, Pi: Rearranges the positions of the lanes
* Step 4, Chi: Applies a non-linear transformation to each row using bitwise operations
* Step 5, Iota: XOR with round-specific constants to prevent symmetry
<ref name="NIST_Fips"/>

== References ==

[[Category:Basic]]

File:Sha3.png

2024-12-17T16:50:41Z

PSimetzberger: The sequence of the Keccak-p permutation.

== Summary ==
The sequence of the Keccak-p permutation.

File:SpongeConstruction.svg.png

2024-12-17T16:49:58Z

PSimetzberger: A model showing the sequence of sponge construction

== Summary ==
A model showing the sequence of sponge construction

CyberChef

2024-12-17T15:51:08Z

PSimetzberger:

Cyberchef is a tool that is used to execute various encoding, encryption, data processing and transformation tasks. It was created by the GCHQ (Government Communications Headquarters) and is also known as the "Cyber Swiss Army Knife", because of its wide variety of operations. A link to a online version can be found in the Readme file in the official github repository (https://github.com/gchq/CyberChef)[1].

== Installation ==
The whole tool can be downloaded using docker. The following command pulls the latest version of the program and starts a container. The webpage can then be seen on the localhost on port 8080 on the browser.

* docker run -it -p 8080:80 ghcr.io/gchq/cyberchef:latest

Alternatively, the program can be build directly. For this the repository needs to be cloned and within the folder the following commands need to be executed.
* docker build --tag cyberchef --ulimit nofile=10000 .
* docker run -it -p 8080:80 cyberchef

== How to use ==

The webpage has 4 important parts.The first one is the Operations tab. There is a list of all functions that can be executed. Double clicking on a function adds it to the second tab called recipe. Alternatively, the function can be dragged into the recipe tab This tab contains a list of all functions that will be executed. The input will go through all functions from top to bottom and the output of the function above will be the input of the function below. The third tab is for the input. Here the user can paste whatever input they want to process. The last tab is for the output. The result of the last function will be posted here.

The tool also allows to save and load recipes.

== References ==
* [1] https://github.com/gchq/CyberChef

[[Category:Basic]]

WebGoat

2024-12-17T15:50:38Z

PSimetzberger:

== Summary ==

This is a tutorial and info site on the OWASP's vulnerable web application WebGoat.

== OWASP WebGoat ==

The OWASP WebGoat project provides an insecure web application that demonstrates the most common client-side application flaws and explains and tests the vulnerabilities from the OWASP Top 10. Lessons, exercises and challenges are provided to give interested developers hands-on experience to test and better understand the material. When starting each lesson, the user is provided with content and interactive questions about the already explained material or demonstrations of the explained functionality through a dialog from different pages. The learning of the content is thus brought to the user in a playful, hands-on experience. The lessons are structured strictly according to the OWASP Top 10 and can be tested and reviewed individually.

=== Learning in three steps ===

1. Explanation of vulnerability

The platform begins by providing a comprehensive explanation of what a vulnerability is, rather than immediately delving into the act of hacking. This approach ensures that users have a solid understanding of the security issue they are dealing with before attempting to exploit it.

2. Learning by doing

Once an individual gains a comprehensive understanding of the vulnerability, WebGoat guides them through practical assignments to apply their knowledge. These assignments are integrated into the learning process, encouraging active engagement and experimentation on the platform. The program follows a 'learning by doing' approach. A 'doing' approach can reinforce understanding of the mechanics of a vulnerability.

3. Explanation of mitigation

At the conclusion of each lesson or exercise, WebGoat explains mitigation techniques. It provides a summary of potential strategies that are crucial for developers and security practitioners. These strategies help secure applications against the specific vulnerability explored, offering practical insights that can be applied. This information improves the resilience of applications to potential attacks in real-world development work.

== Setup ==

There are three possible ways to install the programm: Standalone, Docker Image and cloning the repository (open source) <ref>WebGoat Github, ''WebGoat'', 2022, accessed on: 02.01.2023, [Online]. Available: https://github.com/WebGoat/WebGoat</ref>

=== Requirements ===

* Operating system:
** Windows 8 or higher
** Ubuntu Linux 20.04 LTS or higher
** macOS 10.14 or higher
** Or any other OS which is supported by Java 17
* Java 17 OR Docker Desktop
* Internet Browser of any type
* GIT

=== Installation Instructions ===

==== Run with Docker ====

Need to insall Docker first, then you can install WebGoat as Docker Image.

sudo apt install docker.io
sudo docker run -p 127.0.0.1:8080:8080 -p 127.0.0.1:9090:9090 -e TZ=Europe/Amsterdam webgoat/webgoat

==== Standalone ====

Download .jar file (Java Archive file) from https://github.com/WebGoat/WebGoat/releases
Make sure that you're downloading the latest version.

java -Dfile.encoding=UTF-8 -Dwebgoat.port=8080 -Dwebwolf.port=9090 -jar webgoat-2023.8.jar

==== Run from the sources ====

Clone GitHub Repository (Open Source)

git clone git@github.com:WebGoat/WebGoat.git

Compile the Project using Java 17

cd WebGoat
git checkout <<branch_name>>
# On Linux/Mac:
./mvnw clean install

# On Windows:
./mvnw.cmd clean install

When the priject is compiled successfully we are ready to run the project. WebGoat is using Spring Boot.

# On Linux/Mac:
./mvnw spring-boot:run
# On Windows:
./mvnw.cmd spring-boot:run

=== Access ===
* The landing page will be located at: http://localhost
* WebGoat will be located at: http://localhost:8080/WebGoat
* WebWolf will be located at: http://localhost:9090/WebWolf
<div><ul>
<li style="display: inline-block;"> [[File:Webgoat1.png|thumb|none|500px|Web goat]] </li>
</ul></div>

To gain access to the lessons and challenges, you need to register.

== WebGoat Lessons ==

The OWASP WebGoat Lessons are embedded in the WebGoat Tool. Here, various attack vectors are demonstrated using hands-on examples. In general, WebGoat contains
lessons, exercises and challenges. These lessons are divided into different categories and
contain several pages of information and exercises. The challenges are more demanding
and do not contain any hints. The current version 2023.4 contains 9 lessons:

* (A1) Broken Access Control (Hijack a session, Insecure Direct Object References, Missing Function Level Access Control and Spoofing an Authenticate Cookie)
* (A2) Cryptographic Failures
* (A3) Injection (SQL Injections intro/advanced/mitigation, Path traversal, Cross Site Scripting)
* (A5) Security Misconfiguration (XXE)
* (A6) Vuln & Outdated Components (Vulnerable Components)
* (A7) Identity & Auth Failure (Authentication Bypasses, Insecure Login, JWT tokens, Password reset, Secure Passwords)
* (A8) Software & Data Integrity (Insecure Deserialization)
* (A9) Security Logging Failures (Logging Security)
* (A10) Server-side Request Forgery (Cross-Site Request Forgeries, Server-side Request Forgery)

Each lesson contains further sub-chapters which each contain several pages. In the
first steps, the material is explained, and in the further steps it is explained by means
of exercises.

In the future additional lessons corresponding to the following topics will be added:

* Lesson about cryptography (In Progress)
* Lesson about path traversal (in progress)
* Session Management
* More password reset lessons

== OWASP WebWolf ==

=== Description ===

Since the lessons of WebGoat cover very extensive concepts of penetration testing and
therefore build critical vulnerabilities into the local system to make lessons practically
implementable as well, OWASP decided to provide its own local tool called WebWolf.
WebWolf is automatically delivered with the installation of WebWolf. The tool acts as
a locally hosted attacker machine. This is to highlight more clearly which operations
need to be performed as the attacker and which need to be performed at the target
in order to successfully execute an exploit. Some lessons use WebWolf, for example,
to provide a file that must be loaded onto the target machine (e.g., for persistent XSS
attacks, which will be discussed in more detail later in the thesis) or to provide a
connection to the own environment (ReverseTCP). Since these services should not be
provided in the open and connected Internet, WebWolf was developed.

=== Setup ===

WebWolf is an included tool that is directly in the repository (Git and DockerHub)
and should already be on the machine after downloading WebGoat. If the tool has
already been started via a Docker image, WebWolf is already running and should be
accessible at http://localhost:9090/WebWolf. If the repository is cloned locally in
standalone mode, the WebWolf Java Archive file still needs to be downloaded to start
it locally. This can be done with the following command. If WebWolf has been started
successfully, it will also be available under the above link.

java -jar webwolf<<version>>.jar [--server.port=9090][server.address=localhost]

=== Use ===

WebWolf in the current version (8.2.2) provides the following functionalities:

* File Hosting Service
* Landing Page for incoming requests
* Email Server with Client

== References ==
<references />

[[Category:Documentation]]

CyberChef

2024-12-17T15:49:14Z

PSimetzberger: Created page with "Cyberchef is a tool that is used to execute various encoding, encryption, data processing and transformation tasks. It was created by the GCHQ (Government Communications Headquarters) and is also known as the "Cyber Swiss Army Knife", because of its wide variety of operations. A link to a online version can be found in the Readme file in the official github repository (https://github.com/gchq/CyberChef)[1]. == Installation == The whole tool can be downloaded using docke..."

Cyberchef is a tool that is used to execute various encoding, encryption, data processing and transformation tasks. It was created by the GCHQ (Government Communications Headquarters) and is also known as the "Cyber Swiss Army Knife", because of its wide variety of operations. A link to a online version can be found in the Readme file in the official github repository (https://github.com/gchq/CyberChef)[1].

== Installation ==
The whole tool can be downloaded using docker. The following command pulls the latest version of the program and starts a container. The webpage can then be seen on the localhost on port 8080 on the browser.

* docker run -it -p 8080:80 ghcr.io/gchq/cyberchef:latest

Alternatively, the program can be build directly. For this the repository needs to be cloned and within the folder the following commands need to be executed.
* docker build --tag cyberchef --ulimit nofile=10000 .
* docker run -it -p 8080:80 cyberchef

== How to use ==

The webpage has 4 important parts.The first one is the Operations tab. There is a list of all functions that can be executed. Double clicking on a function adds it to the second tab called recipe. Alternatively, the function can be dragged into the recipe tab This tab contains a list of all functions that will be executed. The input will go through all functions from top to bottom and the output of the function above will be the input of the function below. The third tab is for the input. Here the user can paste whatever input they want to process. The last tab is for the output. The result of the last function will be posted here.

The tool also allows to save and load recipes.

== References ==
* [1] https://github.com/gchq/CyberChef

SHA-3

2024-12-17T15:37:46Z

PSimetzberger: Created page with " SHA-3 is a cryptographic hash function and the newest addition to the SHA family. Guido Bertoni, Joan Daemen, Michael Peeters and Gilles Van Assche created the algorithm with the name Keccak. In 2012 Keccak won the american SHA-3 contest organized by NIST. On the 5th of August 2015 it was standardised, allowing for an alternative to SHA-2 (which is still considered save)[2]. == General information == === Hashing Algorithm === A hashing algorithm is a mathenmatical fun..."

SHA-3 is a cryptographic hash function and the newest addition to the SHA family. Guido Bertoni, Joan Daemen, Michael Peeters and Gilles Van Assche created the algorithm with the name Keccak. In 2012 Keccak won the american SHA-3 contest organized by NIST. On the 5th of August 2015 it was standardised, allowing for an alternative to SHA-2 (which is still considered save)[2].

== General information ==

=== Hashing Algorithm ===
A hashing algorithm is a mathenmatical function that converts an input to a fixed-size output which is often refered as hash value or digest. Hashing is a crucial part of cyber security and widely used in data integrity, verification, cryptography and more.

Hashing algorithms are deterministic, meaning that the same input will always result in the same output. Another characteristic is that a small change in the input leads to significant changes in the hash. Further characteristics can be found under Hashing goals.

=== Hashing goals ===

SHA-3 like every other hashing algorithm pursues the same 5 goals.
* Compression: The algorithm must produce the same fixed length output regardless of the length of the input
* Efficient: It must be fast to calculate the function as it will be calculated a lot.
* Pre-image resistance: Knowing the algorithm and output it should be infeasable to calculate the input
* 2nd Pre-image resistance: Given an input and output of the algorithm, it should be infeasable to calculate a second input resulting in the same output
* Collision resistance: Finding 2 inputs giving the same output should be implausible

=== Hashing Process ===
Algorithms follow a simple 3 step process to calculate the hash.
* Pre-processing: The goal is to get the input in a way the algorithm can handle. This includes processes like padding or splitting the input into blocks
* Initialization: Initial variables and constants are set
* Execution: The actual hashing algorithm is executed

== Calculation ==

=== Sponge construction ===
The Keccak algorithm is a so called sponge construction. It is called that, because it "absorbs" the input and then "squeezes" out the output.

The algorithm uses a 1600-bit array called state which it uses for the caluclations and which will contain the output afterwards. It is divided into 2 parts. The first one is called rate (r) and it will absorb the input. The second part is called capacity (c) and its only function is to make the algorithm more secure.

After the state is initialized, the input message is divided into parts that are as long as the rate. If needed, the last input block will be padded by adding a 1 and then fill it up with 0 to the needed length.

The first input block is now XORed with the state. Afterwards the Keccak algorithm will be used on the state. Then the next block is XORed and the whole process repeats until all chunks are absorbed into the algorithm

Lastly the output is "squeezed" out. The first r bits of the state are taken as the hash value. If the output length is larger than r, the Keccak algorithm will be used again on the state and the next r bits are extraced. This process can repeat until the output length is reached. [1]

=== Keccak-p permutation ===
This is the core component of the SHA-3 algorithm. It contains 5 different operations which are executed in order on the state array. To ensure the hashing goals, multiple rounds of the permutation are done in one call of the algorithm. The default for SHA-3 are 24 rounds, meaning that a single call will execute the Keccak-p permutation 24 times before it returns the state. Because of this, the number of rounds is usually an additional input parameter.
The state is usually divided into a 5x5 matrix with 64 bits in each position.

* Step 1, Theta: XOR each bit with a representative value derived from neighboring columns
* Step 2, Rho: Rotates each lane's bits by a specific offset based on its position
* Step 3, Pi: Rearranges the positions of the lanes
* Step 4, Chi: Applies a non-linear transformation to each row using bitwise operations
* Step 5, Iota: XOR with round-specific constants to prevent symmetry
[1]
== References ==

* [1] https://csrc.nist.gov/pubs/fips/202/final

* [2] https://csrc.nist.gov/projects/hash-functions

[[Category:Basic]]