I will always be here but maybe not every day, I am the same as you guys, 
eating and drinking as well as playing and resting, this is just a simple 
education about Cryptography especially the entropy of each Cryptography that 
you can learn






SHA-256


Part of the SHA-2 family, this algorithm produces a 256-bit (32-byte) hash 
value.


Hᵢ = Hᵢ₋₁ + (Ch(E,F,G) + Σ₁(E) + Wᵢ + Kᵢ)


Recommendations for complex but still easy to apply elementals 


Keccak (SHA-3)


Based on sponge construction, resistant to attacks that compromise SHA-2.


S' = Keccak-p[1600, 24](S ⊕ P)




Suitable for service or service


RIPEMD-256


An improved version of RIPEMD with a 256-bit output size.


H = Lₙ ∥ Rₙ where Lᵢ = F(Lᵢ₋₁, mᵢ)




Stronger than SHA-256 and only suitable for one role per elemental 


RIPEMD-320


Extended version with 320-bit output for enhanced security.


H = Lₙ ∥ Rₙ ∥ Eₙ




Useful for privacy either personal or state E-documents if needed 


SHA-256 Detailed Calculation


// Message Schedule Expansion
For i from 16 to 63:
    s0 = rightrotate(W[i-15], 7) XOR
         rightrotate(W[i-15], 18) XOR (W[i-15] >> 3)
    s1 = rightrotate(W[i-2], 17) XOR
         rightrotate(W[i-2], 19) XOR (W[i-2] >> 10)
    W[i] = W[i-16] + s0 + W[i-7] + s1


// Compression Function
For i from 0 to 63:
    S1 = rightrotate(e, 6) XOR rightrotate(e, 11) XOR rightrotate(e, 25)
    ch = (e AND f) XOR ((NOT e) AND g)
    temp1 = h + S1 + ch + K[i] + W[i]
    S0 = rightrotate(a, 2) XOR rightrotate(a, 13) XOR rightrotate(a, 22)
    maj = (a AND b) XOR (a AND c) XOR (b AND c)
    temp2 = S0 + maj
    h = g
    g = f
    f = e
    e = d + temp1
    d = c
    c = b
    b = a
    a = temp1 + temp2




Warning that Qubits will never exist but SHA-256 needs to be upgraded in the 
temp2 section before later Bit 1 Perform the baseline rate


Keccak (SHA-3) Calculation Framework


// Theta (θ) step
For all pairs (x,z):
    C[x,z] = A[x,0,z] XOR A[x,1,z] XOR A[x,2,z] XOR A[x,3,z] XOR A[x,4,z]
For all pairs (x,z):
    D[x,z] = C[(x-1) mod 5, z] XOR C[(x+1) mod 5, (z-1) mod 64]
For all triples (x,y,z):
    A'[x,y,z] = A[x,y,z] XOR D[x,z]


// Rho (ρ) and Pi (π) steps
For all pairs (x,y):
    (x',y') = (y mod 5, (2x+3y) mod 5)
For all z:
    A''[x',y',z] = A'[x,y,(z-(r[x,y])) mod 64]
where r[x,y] is a rotation constant


// Chi (χ) step
For all triples (x,y,z):
    A'''[x,y,z] = A''[x,y,z] XOR ((NOT A''[(x+1) mod 5,y,z]) AND A''[(x+2) mod 
5,y,z])


// Iota (ι) step - adds round constants
A''''[0,0,z] = A'''[0,0,z] XOR RC[i][z]




Actually, if you create an Altcoin with KECCAK Cryptography, then it is 
irrelevant plus Hackers will easily find loopholes because the constant 
arrangement of this Cryptography is XOR-based


RIPEMD-256 Calculation Structure


// RIPEMD-256 uses two parallel instances of RIPEMD-128
// Initialization Vectors
h0[0..3] = (0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476)
h1[0..3] = (0x76543210, 0xFEDCBA98, 0x89ABCDEF, 0x01234567)


// Processing
For each 512-bit message block:
    // Copy state
    A = h0[0]; B = h0[1]; C = h0[2]; D = h0[3];
    A' = h1[0]; B' = h1[1]; C' = h1[2]; D' = h1[3];


    // 64 steps of transformation
    For t = 0 to 63:
        T = rol_s(A + f(t,B,C,D) + X[r(t)] + K(t), s(t))
        A = D; D = C; C = B; B = T;
        T = rol_s(A' + f(63-t,B',C',D') + X[r'(t)] + K'(t), s'(t))
        A' = D'; D' = C'; C' = B'; B' = T;


    // Combine results
    T = h1[1] + C + D';
    h1[1] = h0[1] + D + A';
    h0[1] = T;


    // Final 256-bit hash is (h0[0], h1[0], h0[1], h1[1], h0[2], h1[2], h0[3], 
h1[3])




This may be suitable for those of you who want to create an Altcoin with solid 
cryptography, but it is necessary to pay attention to excess consumption if 
with this, add 448 Bit EdDSA


RIPEMD-320 Calculation Structure


// RIPEMD-320 uses five parallel instances extended from RIPEMD-160
// Initialization Vectors
h0[0..4] = (0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0)
h1[0..4] = (0x76543210, 0xFEDCBA98, 0x89ABCDEF, 0x01234567, 0x3C2D1E0F)


// Processing
For each 512-bit message block:
    // Copy state
    A1 = h0[0]; B1 = h0[1]; C1 = h0[2]; D1 = h0[3]; E1 = h0[4];
    A2 = h1[0]; B2 = h1[1]; C2 = h1[2]; D2 = h1[3]; E2 = h1[4];


    // 80 steps of transformation with 5 rounds each
    For t = 0 to 79:
        // Left line
        T = rol_s(A1 + f_j(t,B1,C1,D1) + X[r_j(t)] + K_j(t), s_j(t)) + E1;
        A1 = E1; E1 = D1; D1 = rol_10(C1); C1 = B1; B1 = T;


        // Right line
        T = rol_s(A2 + f_j(79-t,B2,C2,D2) + X[r'_j(t)] + K'_j(t), s'_j(t)) + E2;
        A2 = E2; E2 = D2; D2 = rol_10(C2); C2 = B2; B2 = T;


    // Combine results
    T = h1[1] + C1 + D2;
    h1[1] = h0[1] + D1 + E2;
    h0[1] = T;


// Final 320-bit hash combines both line results
// (h0[0], h1[0], h0[1], h1[1], h0[2], h1[2], h0[3], h1[3], h0[4], h1[4])


RIPEMD-320 may not be suitable for all of your Cryptography creations but for 
Privacy it will be suitable if you have a specific wallet, read how the 5 
Rounds work.

Reply via email to