# Implement Secure Hashing Algorithm – 512 ( SHA-512 ) as Functional Programming Paradigm

Last Updated : 11 Apr, 2024

Given a string S of length N, the task is to find the SHA-512 Hash Value of the given string S.

Examples:

Input: S = “GeeksforGeeks”

Input: S = “hello world”
Output:
309ecc489c12d6eb4cc40f50c902f2b4d0ed77ee511a7c7a9bcd3ca86d4cd86f989dd35bc5ff499670da34255b45b0cfd830e81f605dcf7dc5542e93ae9cd76f

Approach: Follow the steps below to solve the problem:

• Convert the given string into the binary form.
• Append ‘1’ to the string and then ‘0’ continuously until length of the string is < (N%(1024 – 128)).
• Add the 128-bit binary representation of N in the string S.
• Find the number of chunks of the size of 1024 and store it in a variable, say chunks as N/1024.
• Divide the string S into 16 chunks of 64 characters.
• Extend the number of chunks to 80 by performing the following operations:
• Iterate over the range [16, 80] and then find 4 values say WordA, WordB, WordC, WordD as:
• WordA = rotate_right(Message[g – 2], 19) ^ rotate_right(Message[g – 2], 61) ^ shift_right(Message[g – 2], 6).
• WordB = Message[g – 7].
• WordC = rotate_right(Message[g – 15], 1) ^ rotate_right(Message[g – 15], 8) ^ shift_right(Message[g – 15], 7).
• WordD = Message[g – 16].
• Update the value of Message[g] as (WordA + WordB + WordC + WordD).
• Initialize 8 variables say A, B, C, D, E, F, G, H of type 64-bit to store the final hash value of the given string S.
• Traverse the array Block[] and perform the following steps:
• Update the value of A, B, C, D, E, F, G, H using the Hash Function till 80 iterations by rotating one by one.
• Now, update the value of A, B, C, D, E, F, G, H by the summation of previous values of A, B, C, D, E, F, G, H and the newly updated value of A, B, C, D, E, F, G, H.
• After completing the above steps, print the hexadecimal values of A, B, C, D, E, F, G, H to get the Hash Value of the given string.

Below is the implementation of the above approach:

Java ```import java.math.BigInteger; public class Main { static final BigInteger[] Constants = { new BigInteger("428a2f98d728ae22", 16), new BigInteger("7137449123ef65cd", 16), new BigInteger("b5c0fbcfec4d3b2f", 16), new BigInteger("e9b5dba58189dbbc", 16), new BigInteger("3956c25bf348b538", 16), new BigInteger("59f111f1b605d019", 16), new BigInteger("923f82a4af194f9b", 16), new BigInteger("ab1c5ed5da6d8118", 16), new BigInteger("d807aa98a3030242", 16), new BigInteger("12835b0145706fbe", 16), new BigInteger("243185be4ee4b28c", 16), new BigInteger("550c7dc3d5ffb4e2", 16), new BigInteger("72be5d74f27b896f", 16), new BigInteger("80deb1fe3b1696b1", 16), new BigInteger("9bdc06a725c71235", 16), new BigInteger("c19bf174cf692694", 16), new BigInteger("e49b69c19ef14ad2", 16), new BigInteger("efbe4786384f25e3", 16), new BigInteger("0fc19dc68b8cd5b5", 16), new BigInteger("240ca1cc77ac9c65", 16), new BigInteger("2de92c6f592b0275", 16), new BigInteger("4a7484aa6ea6e483", 16), new BigInteger("5cb0a9dcbd41fb44", 16), new BigInteger("76f988da831153b5", 16), new BigInteger("983e5152ee66dfab", 16), new BigInteger("a831c66d2db43210", 16), new BigInteger("b00327c898fb213f", 16), new BigInteger("bf597fc7beef0ee4", 16), new BigInteger("c6e00bf33da88fc2", 16), new BigInteger("d5a79147930aa725", 16), new BigInteger("06ca6351e003826f", 16), new BigInteger("142929670a0e6e70", 16), new BigInteger("27b70a8546d22ffc", 16), new BigInteger("2e1b21385c26c926", 16), new BigInteger("4d2c6dfc5ac42aed", 16), new BigInteger("53380d139d95b3df", 16), new BigInteger("650a73548baf63de", 16), new BigInteger("766a0abb3c77b2a8", 16), new BigInteger("81c2c92e47edaee6", 16), new BigInteger("92722c851482353b", 16), new BigInteger("a2bfe8a14cf10364", 16), new BigInteger("a81a664bbc423001", 16), new BigInteger("c24b8b70d0f89791", 16), new BigInteger("c76c51a30654be30", 16), new BigInteger("d192e819d6ef5218", 16), new BigInteger("d69906245565a910", 16), new BigInteger("f40e35855771202a", 16), new BigInteger("106aa07032bbd1b8", 16), new BigInteger("19a4c116b8d2d0c8", 16), new BigInteger("1e376c085141ab53", 16), new BigInteger("2748774cdf8eeb99", 16), new BigInteger("34b0bcb5e19b48a8", 16), new BigInteger("391c0cb3c5c95a63", 16), new BigInteger("4ed8aa4ae3418acb", 16), new BigInteger("5b9cca4f7763e373", 16), new BigInteger("682e6ff3d6b2b8a3", 16), new BigInteger("748f82ee5defb2fc", 16), new BigInteger("78a5636f43172f60", 16), new BigInteger("84c87814a1f0ab72", 16), new BigInteger("8cc702081a6439ec", 16), new BigInteger("90befffa23631e28", 16), new BigInteger("a4506cebde82bde9", 16), new BigInteger("bef9a3f7b2c67915", 16), new BigInteger("c67178f2e372532b", 16), new BigInteger("ca273eceea26619c", 16), new BigInteger("d186b8c721c0c207", 16), new BigInteger("eada7dd6cde0eb1e", 16), new BigInteger("f57d4f7fee6ed178", 16), new BigInteger("06f067aa72176fba", 16), new BigInteger("0a637dc5a2c898a6", 16), new BigInteger("113f9804bef90dae", 16), new BigInteger("1b710b35131c471b", 16), new BigInteger("28db77f523047d84", 16), new BigInteger("32caab7b40c72493", 16), new BigInteger("3c9ebe0a15c9bebc", 16), new BigInteger("431d67c49c100d4c", 16), new BigInteger("4cc5d4becb3e42b6", 16), new BigInteger("597f299cfc657e2a", 16), new BigInteger("5fcb6fab3ad6faec", 16), new BigInteger("6c44198c4a475817", 16) }; static BigInteger[] Message = new BigInteger[80]; public static void main(String[] args) { // Test input string String S = "GeeksForGeeks"; System.out.println(S + ": " + SHA512(S)); } public static String SHA512(String myString) { // Variables for hash computation BigInteger A = new BigInteger("6a09e667f3bcc908", 16); BigInteger B = new BigInteger("bb67ae8584caa73b", 16); BigInteger C = new BigInteger("3c6ef372fe94f82b", 16); BigInteger D = new BigInteger("a54ff53a5f1d36f1", 16); BigInteger E = new BigInteger("510e527fade682d1", 16); BigInteger F = new BigInteger("9b05688c2b3e6c1f", 16); BigInteger G = new BigInteger("1f83d9abfb41bd6b", 16); BigInteger H = new BigInteger("5be0cd19137e2179", 16); // Prepare the input message String s1024 = ""; // Input message as binary string // Conversion of string to binary string omitted for brevity // Padding and length appending omitted for brevity // Calculate the number of blocks int blocksnumber = (s1024.length() + 1023) / 1024; // Split the input message into blocks String[] Blocks = new String[blocksnumber]; // Splitting of input message into blocks omitted for brevity // Process each block in the input message for (int letsgo = 0; letsgo < blocksnumber; ++letsgo) { separator(Blocks[letsgo]); // Initialize temporary variables BigInteger AA = A, BB = B, CC = C, DD = D, EE = E, FF = F, GG = G, HH = H; int count = 0; // Iterations for hash computation omitted for brevity // Update hash values omitted for brevity } // Generate the final hash output String output = ""; // Concatenation of hash values to output string omitted for brevity return output; } // Helper methods omitted for brevity // Separator function to process each block in the message public static void separator(String getBlock) { // Logic for processing each block omitted for brevity } // Compression function for SHA-512 omitted for brevity } ``` JavaScript ```const Constants = [ 0x428a2f98d728ae22n, 0x7137449123ef65cdn, 0xb5c0fbcfec4d3b2fn, 0xe9b5dba58189dbbcn, 0x3956c25bf348b538n, 0x59f111f1b605d019n, 0x923f82a4af194f9bn, 0xab1c5ed5da6d8118n, 0xd807aa98a3030242n, 0x12835b0145706fben, 0x243185be4ee4b28cn, 0x550c7dc3d5ffb4e2n, 0x72be5d74f27b896fn, 0x80deb1fe3b1696b1n, 0x9bdc06a725c71235n, 0xc19bf174cf692694n, 0xe49b69c19ef14ad2n, 0xefbe4786384f25e3n, 0x0fc19dc68b8cd5b5n, 0x240ca1cc77ac9c65n, 0x2de92c6f592b0275n, 0x4a7484aa6ea6e483n, 0x5cb0a9dcbd41fb44n, 0x76f988da831153b5n, 0x983e5152ee66dfabn, 0xa831c66d2db43210n, 0xb00327c898fb213fn, 0xbf597fc7beef0ee4n, 0xc6e00bf33da88fc2n, 0xd5a79147930aa725n, 0x06ca6351e003826fn, 0x142929670a0e6e70n, 0x27b70a8546d22ffcn, 0x2e1b21385c26c926n, 0x4d2c6dfc5ac42aedn, 0x53380d139d95b3dfn, 0x650a73548baf63den, 0x766a0abb3c77b2a8n, 0x81c2c92e47edaee6n, 0x92722c851482353bn, 0xa2bfe8a14cf10364n, 0xa81a664bbc423001n, 0xc24b8b70d0f89791n, 0xc76c51a30654be30n, 0xd192e819d6ef5218n, 0xd69906245565a910n, 0xf40e35855771202an, 0x106aa07032bbd1b8n, 0x19a4c116b8d2d0c8n, 0x1e376c085141ab53n, 0x2748774cdf8eeb99n, 0x34b0bcb5e19b48a8n, 0x391c0cb3c5c95a63n, 0x4ed8aa4ae3418acbn, 0x5b9cca4f7763e373n, 0x682e6ff3d6b2b8a3n, 0x748f82ee5defb2fcn, 0x78a5636f43172f60n, 0x84c87814a1f0ab72n, 0x8cc702081a6439ecn, 0x90befffa23631e28n, 0xa4506cebde82bde9n, 0xbef9a3f7b2c67915n, 0xc67178f2e372532bn, 0xca273eceea26619cn, 0xd186b8c721c0c207n, 0xeada7dd6cde0eb1en, 0xf57d4f7fee6ed178n, 0x06f067aa72176fban, 0x0a637dc5a2c898a6n, 0x113f9804bef90daen, 0x1b710b35131c471bn, 0x28db77f523047d84n, 0x32caab7b40c72493n, 0x3c9ebe0a15c9bebcn, 0x431d67c49c100d4cn, 0x4cc5d4becb3e42b6n, 0x597f299cfc657e2an, 0x5fcb6fab3ad6faecn, 0x6c44198c4a475817n ]; let Message = new Array(80).fill(BigInt(0)); function getHex(bin) { const hexValues = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']; const index = parseInt(bin, 2); return hexValues[index]; } function decimalToHex(deci) { let hexstring = ''; let EQBIN = deci.toString(2).padStart(64, '0'); for (let i = 0; i < EQBIN.length; i += 4) { hexstring += getHex(EQBIN.substr(i, 4)); } return hexstring; } function binaryToDecimal(bin) { return BigInt('0b' + bin); } function rotateRight(x, n) { return (x >> n) | (x << (BigInt(64) - n)); } function shiftRight(x, n) { return x >> n; } function separator(getBlock) { for (let g = 16; g < 80; ++g) { const WordA = rotateRight(Message[g - 2], 19n) ^ rotateRight(Message[g - 2], 61n) ^ shiftRight(Message[g - 2], 6n); const WordB = Message[g - 7]; const WordC = rotateRight(Message[g - 15], 1n) ^ rotateRight(Message[g - 15], 8n) ^ shiftRight(Message[g - 15], 7n); const WordD = Message[g - 16]; const T = WordA + WordB + WordC + WordD; Message[g] = T; } } function maj(a, b, c) { return (a & b) ^ (b & c) ^ (c & a); } function Ch(e, f, g) { return (e & f) ^ (~e & g); } function sigmaE(e) { return rotateRight(e, 14n) ^ rotateRight(e, 18n) ^ rotateRight(e, 41n); } function sigmaA(a) { return rotateRight(a, 28n) ^ rotateRight(a, 34n) ^ rotateRight(a, 39n); } function Func(a, b, c, d, e, f, g, h, K) { const T1 = h + Ch(e, f, g) + sigmaE(e) + Message[K] + Constants[K]; const T2 = sigmaA(a) + maj(a, b, c); d += T1; h = T1 + T2; } function SHA512(myString) { let A = 0x6a09e667f3bcc908n; let B = 0xbb67ae8584caa73bn; let C = 0x3c6ef372fe94f82bn; let D = 0xa54ff53a5f1d36f1n; let E = 0x510e527fade682d1n; let F = 0x9b05688c2b3e6c1fn; let G = 0x1f83d9abfb41bd6bn; let H = 0x5be0cd19137e2179n; const fixedStream = []; for (let i = 0; i < myString.length; ++i) { fixedStream.push(myString.charCodeAt(i).toString(2).padStart(8, '0')); } let s1024 = fixedStream.join(''); const orilen = s1024.length; let tobeadded = 0; const modded = s1024.length % 1024; if (1024 - modded >= 128) { tobeadded = 1024 - modded; } else { tobeadded = 2048 - modded; } s1024 += '1'; s1024 += '0'.repeat(tobeadded - 129); const lengthbits = orilen.toString(2).padStart(128, '0'); s1024 += lengthbits; const blocksnumber = Math.ceil(s1024.length / 1024); const Blocks = new Array(blocksnumber).fill(''); for (let i = 0; i < s1024.length; i += 1024) { Blocks[i / 1024] = s1024.substr(i, 1024); } for (let letsgo = 0; letsgo < blocksnumber; ++letsgo) { separator(Blocks[letsgo]); let AA = A, BB = B, CC = C, DD = D, EE = E, FF = F, GG = G, HH = H; let count = 0; for (let i = 0; i < 10; i++) { Func(A, B, C, D, E, F, G, H, count); count++; Func(H, A, B, C, D, E, F, G, count); count++; Func(G, H, A, B, C, D, E, F, count); count++; Func(F, G, H, A, B, C, D, E, count); count++; Func(E, F, G, H, A, B, C, D, count); count++; Func(D, E, F, G, H, A, B, C, count); count++; Func(C, D, E, F, G, H, A, B, count); count++; Func(B, C, D, E, F, G, H, A, count); count++; } A += AA; B += BB; C += CC; D += DD; E += EE; F += FF; G += GG; H += HH; } let output = ''; output += decimalToHex(A); output += decimalToHex(B); output += decimalToHex(C); output += decimalToHex(D); output += decimalToHex(E); output += decimalToHex(F); output += decimalToHex(G); output += decimalToHex(H); return output; } // Driver Code const S = 'GeeksForGeeks'; console.log(S + ': ' + SHA512(S)); ``` C++14 ```// C++ program for the above approach #include <bits/stdc++.h> using namespace std; typedef unsigned long long int int64; int64 Message[80]; // Stores the hexadecimal values for // calculating hash values const int64 Constants[80] = { 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817 }; // Function to convert a binary string // to hexa-decimal value string gethex(string bin) { if (bin == "0000") return "0"; if (bin == "0001") return "1"; if (bin == "0010") return "2"; if (bin == "0011") return "3"; if (bin == "0100") return "4"; if (bin == "0101") return "5"; if (bin == "0110") return "6"; if (bin == "0111") return "7"; if (bin == "1000") return "8"; if (bin == "1001") return "9"; if (bin == "1010") return "a"; if (bin == "1011") return "b"; if (bin == "1100") return "c"; if (bin == "1101") return "d"; if (bin == "1110") return "e"; if (bin == "1111") return "f"; } // Function to convert a decimal value // to hexa decimal value string decimaltohex(int64 deci) { // Stores the value as string string EQBIN = bitset<64>(deci).to_string(); // Stores the equivalent hexa decimal string hexstring = ""; string temp; // Traverse the string EQBIN for (unsigned int i = 0; i < EQBIN.length(); i += 4) { temp = EQBIN.substr(i, 4); hexstring += gethex(temp); } // Return the hexstring return hexstring; } // Function to convert a binary // string to decimal value int64 BintoDec(string bin) { int64 value = bitset<64>(bin).to_ullong(); return value; } // Function to right rotate x by n bits int64 rotate_right(int64 x, int n) { return (x >> n) | (x << (64 - n)); } // Function to right shift x by n bits int64 shift_right(int64 x, int n) { return (x >> n); } // Function to divide the string // into chunks void separator(string getBlock) { // Stores the size of chunks int chunknum = 0; // Traverse the string S for (unsigned int i = 0; i < getBlock.length(); i += 64, ++chunknum) { // Update the Message[chunknum] Message[chunknum] = BintoDec(getBlock.substr(i, 64)); } // Iterate over the range [16, 80] for (int g = 16; g < 80; ++g) { // Find the WordA int64 WordA = rotate_right(Message[g - 2], 19) ^ rotate_right(Message[g - 2], 61) ^ shift_right(Message[g - 2], 6); // Find the WordB int64 WordB = Message[g - 7]; // Find the WordC int64 WordC = rotate_right(Message[g - 15], 1) ^ rotate_right(Message[g - 15], 8) ^ shift_right(Message[g - 15], 7); // Find the WordD int64 WordD = Message[g - 16]; // Find the resultant code int64 T = WordA + WordB + WordC + WordD; // Return the resultant Hash Code Message[g] = T; } } // Function to find the major of a, b, c int64 maj(int64 a, int64 b, int64 c) { return (a & b) ^ (b & c) ^ (c & a); } // Function to find the ch value of a, // b, and c int64 Ch(int64 e, int64 f, int64 g) { return (e & f) ^ (~e & g); } // Function to find the Bitwise XOR with // the right rotate over 14, 18, and 41 int64 sigmaE(int64 e) { // Return the resultant value return rotate_right(e, 14) ^ rotate_right(e, 18) ^ rotate_right(e, 41); } // Function to find the Bitwise XOR with // the right rotate over 28, 34, and 39 int64 sigmaA(int64 a) { // Return the resultant value return rotate_right(a, 28) ^ rotate_right(a, 34) ^ rotate_right(a, 39); } // Function to generate the hash code void Func(int64 a, int64 b, int64 c, int64& d, int64 e, int64 f, int64 g, int64& h, int K) { // Find the Hash Code int64 T1 = h + Ch(e, f, g) + sigmaE(e) + Message[K] + Constants[K]; int64 T2 = sigmaA(a) + maj(a, b, c); d = d + T1; h = T1 + T2; } // Function to convert the hash value // of a given string string SHA512(string myString) { // Stores the 8 blocks of size 64 int64 A = 0x6a09e667f3bcc908; int64 B = 0xbb67ae8584caa73b; int64 C = 0x3c6ef372fe94f82b; int64 D = 0xa54ff53a5f1d36f1; int64 E = 0x510e527fade682d1; int64 F = 0x9b05688c2b3e6c1f; int64 G = 0x1f83d9abfb41bd6b; int64 H = 0x5be0cd19137e2179; int64 AA, BB, CC, DD, EE, FF, GG, HH; stringstream fixedstream; // Traverse the string S for (int i = 0; i < myString.size(); ++i) { // Add the character to stream fixedstream << bitset<8>(myString[i]); } // Stores string of size 1024 string s1024; // Stores the string in the // fixedstream s1024 = fixedstream.str(); // Stores the length of string int orilen = s1024.length(); int tobeadded; // Find modded string length int modded = s1024.length() % 1024; // If 1024-128 is greater than modded if (1024 - modded >= 128) { tobeadded = 1024 - modded; } // Else if 1024-128 is less than modded else if (1024 - modded < 128) { tobeadded = 2048 - modded; } // Append 1 to string s1024 += "1"; // Append tobeadded-129 zeros // in the string for (int y = 0; y < tobeadded - 129; y++) { s1024 += "0"; } // Stores the binary representation // of string length string lengthbits = std::bitset<128>(orilen).to_string(); // Append the lengthbits to string s1024 += lengthbits; // Find the count of chunks of // size 1024 each int blocksnumber = s1024.length() / 1024; // Stores the numbering of chunks int chunknum = 0; // Stores hash value of each blocks string Blocks[blocksnumber]; // Traverse the string s1024 for (int i = 0; i < s1024.length(); i += 1024, ++chunknum) { Blocks[chunknum] = s1024.substr(i, 1024); } // Traverse the array Blocks[] for (int letsgo = 0; letsgo < blocksnumber; ++letsgo) { // Divide the current string // into 80 blocks size 16 each separator(Blocks[letsgo]); AA = A; BB = B; CC = C; DD = D; EE = E; FF = F; GG = G; HH = H; int count = 0; // Find hash values for (int i = 0; i < 10; i++) { // Find the Hash Values Func(A, B, C, D, E, F, G, H, count); count++; Func(H, A, B, C, D, E, F, G, count); count++; Func(G, H, A, B, C, D, E, F, count); count++; Func(F, G, H, A, B, C, D, E, count); count++; Func(E, F, G, H, A, B, C, D, count); count++; Func(D, E, F, G, H, A, B, C, count); count++; Func(C, D, E, F, G, H, A, B, count); count++; Func(B, C, D, E, F, G, H, A, count); count++; } // Update the value of A, B, C, // D, E, F, G, H A += AA; B += BB; C += CC; D += DD; E += EE; F += FF; G += GG; H += HH; } stringstream output; // Print the hexadecimal value of // strings as the resultant SHA-512 output << decimaltohex(A); output << decimaltohex(B); output << decimaltohex(C); output << decimaltohex(D); output << decimaltohex(E); output << decimaltohex(F); output << decimaltohex(G); output << decimaltohex(H); // Return the string return output.str(); } // Driver Code int main() { // Input string S = "GeeksForGeeks"; // Function Call cout << S << ": " << SHA512(S); return 0; } ```

Output
`GeeksForGeeks: 0acc10c4e0b38617f59e88e49215e2e894afaee5ec948c2af6f44039f03c9fe47a9210e01d5cd926c142bdc9179c2ad30f927a8faf69421ff60a5eaddcf8cb9c`

Time Complexity: O(N)
Auxiliary Space: O(1)

### Python Solution(Using hashlib):

In this approach, we use Python’s hashlib library, specifically sha512() function, to calculate the SHA-512 hash of a string. The function takes the input string encoded as bytes and returns its hexadecimal digest, providing a concise and efficient solution.

Python3 ```import hashlib def sha512(message): # Using hashlib library to calculate SHA-512 hash hash_object = hashlib.sha512(message.encode()) hex_dig = hash_object.hexdigest() return hex_dig # Driver Code if __name__ == "__main__": # Input S = "GeeksForGeeks" # Function Call print(S + ": " + sha512(S)) ```

Output
```GeeksForGeeks: 0acc10c4e0b38617f59e88e49215e2e894afaee5ec948c2af6f44039f03c9fe47a9210e01d5cd926c142bdc9179c2ad30f927a8faf69421ff60a5eaddcf8cb9c
```

Time Complexity: O(N)

Auxiliary Space: O(1)