import java.io.IOException;
public class Keccak
{
private int b, w, l, nr;
/*
* Class implementing the Keccak sponge function
*/
Keccak(int b/* =1600 */)
{
/*
* Constructor: b: parameter b, must be 25, 50, 100, 200, 400, 800 or
* 1600 (default value)
*/
this.setB(b);
}
void setB(int b)
{
/*
* Set the value of the parameter b (and thus w,l and nr)
*
* b: parameter b, must be choosen among [25, 50, 100, 200, 400, 800,
* 1600]
*/
if (b != 25 && b != 50 && b != 100 && b != 200 && b != 400 && b != 800 && b != 1600)
{
throw new RuntimeException("b value not supported - use 25, 50, 100, 200, 400, 800 or 1600");
}
// Update all the parameters based on the used value of b
this.b = b;
this.w = b / 25;
this.l = (int) (Math.log(this.w) / Math.log(2));
this.nr = 12 + 2 * this.l;
}
// Constants
// // Round constants
long[] RC = new long[] { 0x0000000000000001 };// ,
// 0x0000000000008082,
// 0x800000000000808A,
// 0x8000000080008000,
// 0x000000000000808B,
// 0x0000000080000001,
// 0x8000000080008081,
// 0x8000000000008009,
// 0x000000000000008A,
// 0x0000000000000088,
// 0x0000000080008009,
// 0x000000008000000A,
// 0x000000008000808B,
// 0x800000000000008B,
// 0x8000000000008089,
// 0x8000000000008003,
// 0x8000000000008002,
// 0x8000000000000080,
// 0x000000000000800A,
// 0x800000008000000A,
// 0x8000000080008081,
// 0x8000000000008080,
// 0x0000000080000001,
// 0x8000000080008008};
// // Rotation offsets
long[][] r = new long[][] { { 0, 36, 3, 41, 18 }, { 1, 44, 10, 45, 2 }, { 62, 6, 43, 15, 61 }, { 28, 55, 25, 21, 56 }, { 27, 20, 39, 8, 14 } };
// // Generic utility functions
long rot(long x, long n)
{
/*
* Bitwise rotation (to the left) of n bits considering the \ string of
* bits is w bits long
*/
n = n % this.w;
return ((x >> (this.w - n)) + (x << n)) % (1 << this.w);
}
int fromHexStringToLane(String string)
{
/* Convert a string of bytes written in hexadecimal to a lane value */
// Check that the string has an even number of characters i.e. whole
// number of bytes
if (string.length() % 2 != 0)
{
throw new RuntimeException("The provided string does not end with a full byte");
}
// Perform the modification
String temp="";
int nrBytes = string.length() / 2;
for (int i = 0; i < nrBytes; i++)
{
int offset = (nrBytes - i - 1) * 2;
temp += string.substring(offset, offset + 2);
}
return Integer.parseInt(temp, 16);
}
String fromLaneToHexString(long table)
{
/* Convert a lane value to a string of bytes written in hexadecimal */
String laneHexBE = String.format(String.format("%%0%dX", (this.w / 4)), table);
// Perform the modification
String temp="";
int nrBytes = laneHexBE.length() / 2;
for (int i = 0; i < nrBytes; i++)
{
int offset = (nrBytes - i - 1) * 2;
temp += laneHexBE.substring(offset, offset + 2);
}
return temp.toUpperCase();
}
void printState(long[][] state, String info)
{
/*
* Print on screen the state of the sponge function preceded by string
* info
*
* state: state of the sponge function info: a string of characters used
* as identifier
*/
System.out.println("Current value of state: " + info);
for (int y = 0; y < 5; y++)
{
StringBuilder line=new StringBuilder("\t");
for (int x = 0; x < 5; x++)
{
line.append(String.format("%02",state[x][y]));
}
System.out.println(line.toString());
}
}
// //// Conversion functions String <-> Table (and vice-versa)
long[][] convertStrToTable(String string)
{
/*
* Convert a string of bytes to its 5×5 matrix representation
*
* string: string of bytes of hex-coded bytes (e.g. '9A2C...");
*/
// Check that input paramaters
if (this.w % 8 != 0)
{
throw new RuntimeException("w is not a multiple of 8");
}
if (string.length() != 2 * (this.b) / 8)
{
throw new RuntimeException("string can't be divided in 25 blocks of w bits i.e. string must have exactly b bits");
}
// Convert
long[][] output = { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } };
for (int x = 0; x < 5; x++)
{
for (int y = 0; y < 5; y++)
{
int offset = 2 * ((5 * y + x) * this.w) / 8;
output[x][y] = this.fromHexStringToLane(string.substring(offset, offset + (2 * this.w / 8)));
}
}
return output;
}
String convertTableToStr(long[][] table){
/*Convert a 5×5 matrix representation to its string representation*/
//Check input format
if(this.w%8!= 0){
throw new RuntimeException("w is not a multiple of 8");
}
if (table.length!=5){
throw new RuntimeException("table must be 5×5");}
for (int i = 0; i < table.length; i++)
if (table[i].length!=5){
throw new RuntimeException("table must be 5×5");
}
//Convert
String output="";
for(int y = 0; y < 5; y++)
{
for(int x = 0; x < 5; x++)
{
output+=this.fromLaneToHexString(table[x][y]);
}
}
return output.toUpperCase();
}
long[][] Round(long[][] A, long m)
{
/*
* Perform one round of computation as defined in the Keccak-f
* permutation
*
* A: current state (5×5 matrix) RCfixed: value of round constant to use
* (integer)
*/
// Initialisation of temporary variables
long[][] B = { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } };
long[] C = { 0, 0, 0, 0, 0 };
long[] D = { 0, 0, 0, 0, 0 };
// Theta step
for (int x = 0; x < 5; x++)
{
C[x] = A[x][0] ^ A[x][1] ^ A[x][2] ^ A[x][3] ^ A[x][4];
}
for (int x = 0; x < 5; x++)
{
D[x] = C[(x - 1) % 5] ^ this.rot(C[(x + 1) % 5], 1);
}
for (int x = 0; x < 5; x++)
{
for (int y = 0; y < 5; y++)
{
A[x][y] = A[x][y] ^ D[x];
}
}
// Rho and Pi steps
for (int x = 0; x < 5; x++)
{
for (int y = 0; y < 5; y++)
{
B[y][(2 * x + 3 * y) % 5] = this.rot(A[x][y], this.r[x][y]);
}
}
// Chi step
for (int x = 0; x < 5; x++)
{
for (int y = 0; y < 5; y++)
{
A[x][y] = B[x][y] ^ ((~B[(x + 1) % 5][y]) & B[(x + 2) % 5][y]);
}
}
// Iota step
A[0][0] = A[0][0] ^ m;
return A;
}
long[][] KeccakF(long[][] A, boolean verbose/* =False */)
{
/*
* Perform Keccak-f function on the state A
*
* A: 5×5 matrix containing the state verbose: a boolean flag activating
* the printing of intermediate computations
*/
if (verbose)
{
this.printState(A, "Before first round");
}
for (int i = 0; i < this.nr; i++)
{
// NB: result is truncated to lane size
A = this.Round(A, this.RC[i] % (1 << this.w));
if (verbose)
{
this.printState(A, String.format("Satus end of round #%d/%d", i + 1, this.nr));
}
}
return A;
}
public String pad10star1(int m, String M, int n)
{
// Padded die Nachricht M, so dass eine vielfache Länge von r erreicht
// wird
// M: message pair (length in bits, string of hex characters
// ('9AFC...");
// n: length in bits (must be a multiple of 8)
// Example: pad10star1([60, 'BA594E0FB9EBBD30'],8) returns
// 'BA594E0FB9EBBD93'
int my_string_length = m;
String my_string = M;
if (n % 8 != 0)
{
throw new RuntimeException("n must be a multiple of 8");
}
// Check the length of the provided string
if (my_string.length() % 2 != 0)
{
// Pad with one '0' to reach correct length (don't know test vectors
// coding)
my_string += '0';
}
if (my_string_length > my_string.length() / 2 * 8)
{
throw new RuntimeException("the string is too short to contain the number of bits announced");
}
int nr_bytes_filled = my_string_length / 8;
int nbr_bits_filled = my_string_length % 8;
int l = my_string_length % n;
int my_byte;
if ((n - 8) <= l && l <= (n - 2))
{
if (nbr_bits_filled == 0)
{
my_byte = 0;
} else
{
my_byte = Integer.parseInt(my_string.substring(nr_bytes_filled * 2, nr_bytes_filled * 2 + 2), 16);
}
my_byte = (my_byte >> (8 - nbr_bits_filled));
my_byte = my_byte + (1 << (nbr_bits_filled)) + (1 << 7);
String hex = String.format("%02X", my_byte);
my_string = my_string.substring(0, nr_bytes_filled * 2) + hex;
} else
{
if (nbr_bits_filled == 0)
{
my_byte = 0;
} else
{
my_byte = Integer.parseInt(my_string.substring(nr_bytes_filled * 2, nr_bytes_filled * 2 + 2), 16);
}
my_byte = (my_byte >> (8 - nbr_bits_filled));
my_byte = my_byte + (1 << (nbr_bits_filled));
String hex = String.format("%02X", my_byte);
my_string = my_string.substring(0, nr_bytes_filled * 2) + hex;
while ((8 * my_string.length() / 2) % n < (n - 8))
{
my_string += "00";
}
my_string += "80";
}
return my_string;
}
public String Keccak(int m, String M, int r/* =1024 */, int c/* =576 */, int n/*
* =
* 1024
*/, boolean verbose/*
* =
* False
*/)
{
/*
* Compute the Keccak[r,c,d] sponge function on message M M: message
* pair (length in bits, string of hex characters ('9AFC..."); r:
* bitrate in bits (defautl: 1024) c: capacity in bits (default: 576) n:
* length of output in bits (default: 1024), verbose: print the details
* of computations(default:False)
*/
// Check the inputs
if (r < 0 || r % 8 != 0)
{
throw new RuntimeException("r must be a multiple of 8 in this implementation");
}
if (n % 8 != 0)
{
throw new RuntimeException("outputLength must be a multiple of 8");
}
this.setB(r + c);
if (verbose)
{
System.out.println(String.format("Create a Keccak function with (r=%d, c=%d (i.e. w=%d))", r, c, (r + c) / 25));
}
// Compute lane length (in bits)
w = (r + c) / 25;
// Initialisation of state
long[][] S = new long[][] { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } };
// Padding of messages
String P = this.pad10star1(m, M, r);
if (verbose)
{
System.out.println(String.format("String ready to be absorbed: %s (will be completed by %d x '00')", P, c / 8));
}
// Absorbing phase
for (int i = 0; i < ((P.length() * 8 / 2) / r); i++)
{
long[][] Pi = this.convertStrToTable(String.format("%s%0" + c / 4 + "d", P.substring(i * (2 * r / 8), (i + 1) * (2 * r / 8)), 0));
for (int y = 0; y < 5; y++)
{
for (int x = 0; x < 5; x++)
{
S[x][y] = S[x][y] ^ Pi[x][y];
}
}
S = this.KeccakF(S, verbose);
}
if (verbose)
{
System.out.println("Value after absorption : " + (this.convertTableToStr(S)));
}
// Squeezing phase
String Z = "";
int outputLength = n;
while (outputLength > 0)
{
String string = this.convertTableToStr(S);
Z = Z + string.substring(0, r * 2 / 8);
outputLength -= r;
if (outputLength > 0)
{
S = this.KeccakF(S, verbose);
}
}
// NB: done by block of length r, could have to be cut if outputLength
// is not a multiple of r
if (verbose)
{
System.out.println("Value after squeezing : %s " + (this.convertTableToStr(S)));
}
return Z.substring(0, 2 * n / 8);
}
public static void main(String[] args)
{
Keccak k = new Keccak(1600);
System.out.println(k.pad10star1(60, "BA594E0FB9EBBD30", 8));
System.out.println(k.pad10star1(29, "53587BC8", 104 * 8));
}
}
