Rosetta Code

SHA-256: Difference between revisions

Page Discussion

SHA-256 (view source)

Revision as of 15:25, 5 February 2024

14,592 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
No edit summary
m (→‎{{header|Wren}}: Minor tidy)
 
(17 intermediate revisions by 11 users not shown)
Line 5:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang="aarch64 assembly">
<lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program sha256_64.s */
Line 412:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
</lang>
{{Output}}
<pre>
Line 421:
=={{header|Ada}}==
{{libheader|CryptAda}}
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
 
with CryptAda.Pragmatics;
Line 454:
Ada.Text_IO.Put_Line
("""" & Text & """: " & CryptAda.Utils.Format.To_Hex_String (Hashes.Get_Bytes (Hash)));
end RC_SHA_256;</langsyntaxhighlight>
{{out}}
<pre>"Rosetta code": 764FAF5C61AC315F1497F9DFA542713965B785E5CC2F707D6468D7D1124CDFCF</pre>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
<lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program sha256.s */
Line 836:
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
</lang>
{{Output}}
<pre>
Line 844:
=={{header|AutoHotkey}}==
Source: [https://github.com/jNizM/AutoHotkey_Scripts/tree/master/Functions/Checksums SHA-256 @github] by jNizM
<langsyntaxhighlight AutoHotkeylang="autohotkey">str := "Rosetta code"
MsgBox, % "File:`n" (file) "`n`nSHA-256:`n" FileSHA256(file)
 
Line 893:
StrPut(string, &data, floor(length / chrlength), encoding)
return CalcAddrHash(&data, length, algid, hash, hashlength)
}</langsyntaxhighlight>
{{out}}
<pre>String: Rosetta code
Line 900:
=={{header|AWK}}==
Using the system function as a 'library'.
<syntaxhighlight lang="awk">{
<lang AWK>{
("echo -n " $0 " | sha256sum") | getline sha;
gsub(/[^0-9a-zA-Z]/, "", sha);
print sha;
}
</syntaxhighlight>
</lang>
 
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
 
=={{header|BaConBASIC}}==
==={{header|BaCon}}===
<lang qbasic>PRAGMA INCLUDE <openssl/sha.h>
<syntaxhighlight lang="qbasic">PRAGMA INCLUDE <openssl/sha.h>
PRAGMA LDFLAGS -lcrypto
 
Line 924 ⟶ 925:
NEXT
 
PRINT</langsyntaxhighlight>
{{out}}
<pre>
Line 936 ⟶ 937:
</pre>
 
==={{header|BBC BASIC}}===
====Library====
{{works with|BBC BASIC for Windows}}
<langsyntaxhighlight lang="bbcbasic"> PRINT FNsha256("Rosetta code")
END
Line 963 ⟶ 964:
hash$ += RIGHT$("0" + STR$~buffer%?i%, 2)
NEXT
= hash$</langsyntaxhighlight>
{{out}}
'''Output:'''
<pre>
764FAF5C61AC315F1497F9DFA542713965B785E5CC2F707D6468D7D1124CDFCF
</pre>
 
====Native====
{{works with|BBC BASIC for Windows}}
<langsyntaxhighlight lang="bbcbasic"> REM SHA-256 calculation by Richard Russell in BBC BASIC for Windows
REM Must run in FLOAT64 mode:
Line 1,094 ⟶ 1,095:
WHILE n# > &7FFFFFFF : n# -= 2^32 : ENDWHILE
WHILE n# < &80000000 : n# += 2^32 : ENDWHILE
= n#</langsyntaxhighlight>
{{out}}
'''Output:'''
<pre>
764FAF5C 61AC315F 1497F9DF A5427139 65B785E5 CC2F707D 6468D7D1 124CDFCF
Line 1,102 ⟶ 1,103:
=={{header|C}}==
Requires OpenSSL, compile flag: <code>-lssl -lcrypto</code>
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <string.h>
#include <openssl/sha.h>
Line 1,116 ⟶ 1,117:
 
return 0;
}</langsyntaxhighlight>
 
=={{header|C sharp}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Security.Cryptography;
using System.Text;
Line 1,140 ⟶ 1,141:
}
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
Line 1,148 ⟶ 1,149:
Missing description how to use g++ or other program linux\windows 10
 
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <cryptopp/filters.h>
#include <cryptopp/hex.h>
Line 1,167 ⟶ 1,168:
return 0;
}
</syntaxhighlight>
</lang>
 
===Implementation===
<syntaxhighlight lang="c++">
#include <bit>
#include <cstdint>
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
class SHA256 {
public:
std::string message_digest(const std::string& message) {
std::vector<int64_t> hash = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
 
const std::vector<int8_t> bytes = add_padding(message);
for ( uint64_t i = 0; i < bytes.size() / BLOCK_LENGTH; ++i ) {
std::vector<int32_t> words(BLOCK_LENGTH, 0);
for ( int32_t j = 0; j < BLOCK_LENGTH; ++j ) {
words[j / 4] |= ( bytes[i * BLOCK_LENGTH + j] & 0xff ) << ( ( 3 - j % 4 ) * 8 );
}
for ( int32_t j = 16; j < BLOCK_LENGTH; j++ ) {
words[j] = sigma(3, words[j - 2]) + words[j - 7] + sigma(2, words[j - 15]) + words[j - 16];
}
 
int32_t a = hash[0], b = hash[1], c = hash[2], d = hash[3],
e = hash[4], f = hash[5], g = hash[6], h = hash[7];
 
for ( int32_t j = 0; j < BLOCK_LENGTH; ++j ) {
int32_t t = h + sigma(1, e) + ch(e, f, g) + kk[j] + words[j];
int32_t tt = sigma(0, a) + maj(a, b, c);
h = g; g = f; f = e;
e = d + t;
d = c; c = b; b = a;
a = t + tt;
}
 
hash[0] += a; hash[1] += b; hash[2] += c; hash[3] += d;
hash[4] += e; hash[5] += f; hash[6] += g; hash[7] += h;
}
 
std::stringstream stream;
for ( int32_t i = 0; i < BLOCK_LENGTH; ++i ) {
int8_t byte_value = static_cast<int8_t>(hash[i / 8] >> ( 7 - i % 8 ) * 4);
stream << std::hex << ( byte_value & 0xf );
}
return stream.str();
}
 
private:
std::vector<int8_t> add_padding(const std::string& message) {
std::vector<int8_t> bytes(message.begin(), message.end());
bytes.emplace_back(static_cast<uint8_t>(0x80));
 
uint32_t padding = BLOCK_LENGTH - ( bytes.size() % BLOCK_LENGTH );
if ( padding < 8 ) {
padding += BLOCK_LENGTH;
}
bytes.resize(bytes.size() + padding - 8, static_cast<int8_t>(0x0));
 
const uint64_t bit_length = 8 * message.length();
for ( int32_t i = 7; i >= 0; --i ) {
bytes.emplace_back(static_cast<int8_t>(bit_length >> ( 8 * i )));
}
return bytes;
}
 
int32_t sigma(const uint32_t& group, const uint32_t& x) {
int32_t result;
switch ( group ) {
case 0 : result = std::rotr(x, 2) ^ std::rotr(x, 13) ^ std::rotr(x, 22); break;
case 1 : result = std::rotr(x, 6) ^ std::rotr(x, 11) ^ std::rotr(x, 25); break;
case 2 : result = std::rotr(x, 7) ^ std::rotr(x, 18) ^ ( x >> 3 ); break;
case 3 : result = std::rotr(x, 17) ^ std::rotr(x, 19) ^ ( x >> 10 ); break;
default : throw std::invalid_argument("Unexpected argument for sigma: " + std::to_string(group));
}
return result;
}
 
int32_t ch(const int32_t& x, const int32_t y, const int32_t z) {
return ( x & y ) ^ ( ~x & z );
}
 
int32_t maj(const int32_t& x, const int32_t y, const int32_t z) {
return ( x & y ) ^ ( x & z ) ^ ( y & z );
}
 
const std::vector<int64_t> kk = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
 
const int32_t BLOCK_LENGTH = 64;
};
 
int main() {
SHA256 sha256;
std::cout << sha256.message_digest("Rosetta code") << std::endl;
}
</syntaxhighlight>
{{ out }}
<pre>
764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
</pre>
 
=={{header|Caché ObjectScript}}==
Line 1,178 ⟶ 1,290:
=={{header|Clojure}}==
{{libheader|pandect}}
<langsyntaxhighlight lang="clojure">(use 'pandect.core)
(sha256 "Rosetta code")</langsyntaxhighlight>
 
{{Out}}
Line 1,186 ⟶ 1,298:
=={{header|Common Lisp}}==
{{libheader|Ironclad}}
<langsyntaxhighlight lang="lisp">(ql:quickload 'ironclad)
(defun sha-256 (str)
(ironclad:byte-array-to-hex-string
Line 1,192 ⟶ 1,304:
(ironclad:ascii-string-to-byte-array str))))
 
(sha-256 "Rosetta code")</langsyntaxhighlight>
 
{{Out}}
Line 1,198 ⟶ 1,310:
 
=={{header|Crystal}}==
<langsyntaxhighlight lang="ruby">require "openssl"
puts OpenSSL::Digest.new("SHA256").update("Rosetta code")
</syntaxhighlight>
</lang>
Output:
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 1,206 ⟶ 1,318:
=={{header|D}}==
===Standard Version===
<langsyntaxhighlight lang="d">void main() {
import std.stdio, std.digest.sha;
 
writefln("%-(%02x%)", "Rosetta code".sha256Of);
}</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
 
===Simple Implementation===
<langsyntaxhighlight lang="d">// Copyright (C) 2005, 2006 Free Software Foundation, Inc. GNU License.
// Translated to D language. Only lightly tested, not for serious use.
 
Line 1,316 ⟶ 1,428:
pure nothrow @nogc in {
assert(inBuffer.length % 64 == 0);
} bodydo {
// Round functions.
static uint F1(in uint e, in uint f, in uint g) pure nothrow @safe @nogc {
Line 1,562 ⟶ 1,674:
writefln("%(%02x%)", SHA256.digest(data));
}
}</langsyntaxhighlight>
Compile with -version=sha_256_main to run the main function.
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
This is a moderately efficient implementation, about 100 MB/s on a 4096 bytes input buffer on a 32 bit system, using the ldc2 compiler. On a more modern CPU (Intel Ivy Bridge) using HyperThreading, handwritten assembly by Intel is about twice faster.
 
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
{{libheader| DCPsha256}} Part of '''DCPcrypt Cryptographic Component Library v2.1'''[https://bitbucket.org/wpostma/dcpcrypt2010] by David Barton.
<syntaxhighlight lang="delphi">
<lang Delphi>
program SHA_256;
 
Line 1,603 ⟶ 1,716:
end.
 
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,609 ⟶ 1,722:
</pre>
=={{header|DWScript}}==
<langsyntaxhighlight lang="delphi">PrintLn( HashSHA256.HashData('Rosetta code') );</langsyntaxhighlight>
 
=={{header|Emacs Lisp}}==
<langsyntaxhighlight Lisplang="lisp">(secure-hash 'sha256 "Rosetta code") ;; as string of hex digits</langsyntaxhighlight>
 
=={{header|Erlang}}==
Line 1,624 ⟶ 1,737:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">open System.Security.Cryptography
open System.Text
 
Line 1,632 ⟶ 1,745:
|> System.BitConverter.ToString
|> printfn "%s"
</syntaxhighlight>
</lang>
{{out}}
<pre>76-4F-AF-5C-61-AC-31-5F-14-97-F9-DF-A5-42-71-39-65-B7-85-E5-CC-2F-70-7D-64-68-D7-D1-12-4C-DF-CF
Line 1,639 ⟶ 1,752:
=={{header|Factor}}==
{{works with|Factor|0.98}}
<langsyntaxhighlight lang="factor">USING: checksums checksums.sha io math.parser ;
 
"Rosetta code" sha-256 checksum-bytes bytes>hex-string print</langsyntaxhighlight>
{{out}}
<pre>
Line 1,650 ⟶ 1,763:
===GNU Forth 0.7.9 on Linux===
Uses the information from the C version on which libraries to reference.
<syntaxhighlight lang="forth">
<lang Forth>
c-library crypto
 
Line 1,668 ⟶ 1,781:
s" Rosetta code" 0 sha256 .digest cr
bye
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 1,682 ⟶ 1,795:
764FAF5C61AC315F1497F9DFA542713965B785E5CC2F707D6468D7D1124CDFCF rc.txt (12 bytes)</pre>
 
<langsyntaxhighlight lang="fortran">module sha256_mod
use kernel32
use advapi32
Line 1,777 ⟶ 1,890:
deallocate(name)
end do
end program</langsyntaxhighlight>
 
=={{header|Free Pascal}}==
<langsyntaxhighlight lang="pascal">program rosettaCodeSHA256;
 
uses
Line 1,807 ⟶ 1,920:
writeln(lowerCase(output));
 
end.</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">' version 20-10-2016
' FIPS PUB 180-4
' compile with: fbc -s console
Line 1,944 ⟶ 2,057:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>Rosetta code => 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 1,950 ⟶ 2,063:
=={{header|Frink}}==
Frink has convenience methods to use any message hashing algorithm provided by your Java Virtual Machine. The result can be returned as a hexadecimal string, an integer, or an array of bytes.
<langsyntaxhighlight lang="frink">println[messageDigest["Rosetta code", "SHA-256"]]</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 1,957 ⟶ 2,070:
A SHA-256 function can be defined using the Java support library.
 
<langsyntaxhighlight lang="funl">native java.security.MessageDigest
 
def sha256Java( message ) = map( a -> format('%02x', a), list(MessageDigest.getInstance('SHA-256').digest(message.getBytes('UTF-8'))) ).mkString()</langsyntaxhighlight>
 
Here is a definition implemented as a direct translation of the pseudocode at '''[[wp:SHA-256|SHA-256]]'''.
 
<langsyntaxhighlight lang="funl">def sha256( message ) =
//Initialize hash values
h0 = 0x6a09e667
Line 2,045 ⟶ 2,158:
 
// Produce the final hash value (big-endian)
map( a -> format('%08x', a.intValue()), [h0, h1, h2, h3, h4, h5, h6, h7] ).mkString()</langsyntaxhighlight>
 
Here is a test comparing the two and also verifying the hash values of the empty message string.
 
<langsyntaxhighlight lang="funl">message = 'Rosetta code'
 
println( 'FunL: "' + message + '" ~> ' + sha256(message) )
Line 2,057 ⟶ 2,170:
 
println( 'FunL: "' + message + '" ~> ' + sha256(message) )
println( 'Java: "' + message + '" ~> ' + sha256Java(message) )</langsyntaxhighlight>
 
{{out}}
Line 2,069 ⟶ 2,182:
 
=={{header|Genie}}==
<langsyntaxhighlight lang="genie">[indent=4]
/*
SHA-256 in Genie
Line 2,083 ⟶ 2,196:
print digest
 
assert(digest == "764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf")</langsyntaxhighlight>
 
{{out}}
Line 2,092 ⟶ 2,205:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 2,106 ⟶ 2,219:
}
fmt.Printf("%x\n", h.Sum(nil))
}</langsyntaxhighlight>
{{out}}
<pre>
Line 2,113 ⟶ 2,226:
 
=={{header|Groovy}}==
<langsyntaxhighlight lang="groovy">def sha256Hash = { text ->
java.security.MessageDigest.getInstance("SHA-256").digest(text.bytes)
.collect { String.format("%02x", it) }.join('')
}</langsyntaxhighlight>
Testing
<langsyntaxhighlight lang="groovy">assert sha256Hash('Rosetta code') == '764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf'</langsyntaxhighlight>
 
=={{header|Halon}}==
<langsyntaxhighlight lang="halon">$var = "Rosetta code";
echo sha2($var, 256);</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.Char (ord)
import Crypto.Hash.SHA256 (hash)
import Data.ByteString (unpack, pack)
Line 2,139 ⟶ 2,252:
map (fromIntegral.ord) -- to array of Word8
"Rosetta code"
</syntaxhighlight>
</lang>
{{out}}
<pre style="font-size:80%">764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
Line 2,145 ⟶ 2,258:
 
=={{header|Haxe}}==
<langsyntaxhighlight lang="haxe">import haxe.crypto.Sha256;
 
class Main {
Line 2,152 ⟶ 2,265:
Sys.println(sha256);
}
}</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 2,159 ⟶ 2,272:
'''Solution:'''
From J8 the <tt>ide/qt</tt> addon provides bindings to Qt libraries that include support for various hashing algorithms including SHA-256.
<langsyntaxhighlight lang="j">require '~addons/ide/qt/qt.ijs'
getsha256=: 'sha256'&gethash_jqtide_</langsyntaxhighlight>
'''Example Usage:'''
<langsyntaxhighlight lang="j"> getsha256 'Rosetta code'
764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</langsyntaxhighlight>
 
Note that the older version Qt4 libraries currently shipped by default on many Linux distributions don't support SHA-256. On Windows and Mac, J8 includes the later Qt5 libraries that include support for SHA-256.
Line 2,169 ⟶ 2,282:
Starting in J8.06, the sha family of hashes have built-in support.
 
<langsyntaxhighlight lang="j">sha256=: 3&(128!:6)</langsyntaxhighlight>
 
<langsyntaxhighlight lang="j"> sha256 'Rosetta code'
764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</langsyntaxhighlight>
 
=={{header|Java}}==
The solution to this task would be a small modification to [[MD5#Java|MD5]] (replacing "MD5" with "SHA-256" as noted [http://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#MessageDigest here]).
 
===Implementation===
<syntaxhighlight lang = "java">
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
 
public final class SHA256Task {
 
public static void main(String[] args) {
System.out.println(SHA256.messageDigest("Rosetta code"));
}
 
}
 
final class SHA256 {
public static String messageDigest(String message) {
int[] hash = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
final byte[] bytes = addPadding(message);
for ( int i = 0; i < bytes.length / BLOCK_LENGTH; i++ ) {
int[] words = new int[BLOCK_LENGTH];
for ( int j = 0; j < BLOCK_LENGTH; j++ ) {
words[j / 4] |= ( bytes[i * BLOCK_LENGTH + j] & 0xff ) << ( ( 3 - j % 4 ) * 8 );
}
for ( int j = 16; j < BLOCK_LENGTH; j++ ) {
words[j] = sigma(3, words[j - 2]) + words[j - 7] + sigma(2, words[j - 15]) + words[j - 16];
}
int a = hash[0], b = hash[1], c = hash[2], d = hash[3],
e = hash[4], f = hash[5], g = hash[6], h = hash[7];
for ( int j = 0; j < BLOCK_LENGTH; j++ ) {
int t = h + sigma(1, e) + ch(e, f, g) + kk[j] + words[j];
int tt = sigma(0, a) + maj(a, b, c);
h = g; g = f; f = e;
e = d + t;
d = c; c = b; b = a;
a = t + tt;
}
 
hash[0] += a; hash[1] += b; hash[2] += c; hash[3] += d;
hash[4] += e; hash[5] += f; hash[6] += g; hash[7] += h;
}
StringBuilder result = new StringBuilder();
for ( int i = 0; i < BLOCK_LENGTH; i++ ) {
result.append(String.format("%1x", ( hash[i / 8] >>> ( 7 - i % 8 ) * 4 ) & 0xf ));
}
return result.toString();
}
private static byte[] addPadding(String message) {
byte[] bytes = message.getBytes(StandardCharsets.UTF_8);
bytes = Arrays.copyOf(bytes, bytes.length + 1);
bytes[bytes.length - 1] = (byte) 0x80;
int padding = BLOCK_LENGTH - ( bytes.length % BLOCK_LENGTH );
if ( padding < 8 ) {
padding += BLOCK_LENGTH;
}
bytes = Arrays.copyOf(bytes, bytes.length + padding);
final long bitLength = message.length() * 8;
for ( int i = 0; i < 8; i++ ) {
bytes[bytes.length - 1 - i] = (byte) ( bitLength >>> ( 8 * i ) );
}
return bytes;
}
private static int sigma(int group, int x) {
return switch ( group ) {
case 0 -> Integer.rotateRight(x, 2) ^ Integer.rotateRight(x, 13) ^ Integer.rotateRight(x, 22);
case 1 -> Integer.rotateRight(x, 6) ^ Integer.rotateRight(x, 11) ^ Integer.rotateRight(x, 25);
case 2 -> Integer.rotateRight(x, 7) ^ Integer.rotateRight(x, 18) ^ ( x >>> 3 );
case 3 -> Integer.rotateRight(x, 17) ^ Integer.rotateRight(x, 19) ^ ( x >>> 10 );
default -> throw new AssertionError("Unexpected argument for sigma: " + group);
};
}
private static int ch(int x, int y, int z) {
return ( x & y ) ^ ( ~x & z );
}
 
private static int maj(int x, int y, int z) {
return ( x & y ) ^ ( x & z ) ^ ( y & z );
}
private static final int[] kk = new int[] {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
private static final int BLOCK_LENGTH = 64;
}
</syntaxhighlight>
{{ out }}
<pre>
764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
</pre>
 
=={{header|JavaScript}}==
<langsyntaxhighlight lang="javascript">
const crypto = require('crypto');
 
Line 2,185 ⟶ 2,405:
 
console.log(hash);
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,192 ⟶ 2,412:
 
=={{header|Jsish}}==
<langsyntaxhighlight lang="javascript">/* SHA-256 hash in Jsish */
var str = 'Rosetta code';
puts(Util.hash(str, {type:'sha256'}));
Line 2,200 ⟶ 2,420:
764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
=!EXPECTEND!=
*/</langsyntaxhighlight>
 
{{out}}
Line 2,211 ⟶ 2,431:
{{works with|Julia|0.6}}
 
<langsyntaxhighlight lang="julia">msg = "Rosetta code"
 
using Nettle
Line 2,220 ⟶ 2,440:
digest1 = join(num2hex.(sha256(msg)))
 
@assert digest == digest1</langsyntaxhighlight>
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.0.6
 
import java.security.MessageDigest
Line 2,234 ⟶ 2,454:
for (byte in digest) print("%02x".format(byte))
println()
}</langsyntaxhighlight>
 
{{out}}
Line 2,248 ⟶ 2,468:
Use the cipher_list method to view these algorithms.
 
<langsyntaxhighlight Lassolang="lasso">// The following will return a list of all the cipher
// algorithms supported by the installation of Lasso
cipher_list
Line 2,258 ⟶ 2,478:
// return the SHA-256 digest. Dependant on SHA-256 being an available digest method
cipher_digest('Rosetta Code', -digest='SHA-256',-hex=true)
</syntaxhighlight>
</lang>
 
=={{header|Lua}}==
Line 2,265 ⟶ 2,485:
{{libheader|sha2}} ([http://code.google.com/p/sha2/ luarocks install sha2])
 
<langsyntaxhighlight Lualang="lua">#!/usr/bin/lua
 
require "sha2"
 
print(sha2.sha256hex("Rosetta code"))</langsyntaxhighlight>
 
{{out}}
Line 2,275 ⟶ 2,495:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="text">Hash["Rosetta code","SHA256","HexString"]</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 2,281 ⟶ 2,501:
=={{header|min}}==
{{works with|min|0.19.6}}
<langsyntaxhighlight lang="min">"Rosetta code" sha256 puts!</langsyntaxhighlight>
{{out}}
<pre>
Line 2,289 ⟶ 2,509:
=={{header|NetRexx}}==
This solution is basically the same as that for [[MD5#NetRExx|MD5]], substituting "SHA-256" for "MD5" as the algorithm to use in the <tt>MessageDigest</tt> instance.
<langsyntaxhighlight NetRexxlang="netrexx">/* NetRexx */
options replace format comments java crossref savelog symbols binary
 
Line 2,339 ⟶ 2,559:
return digestSum
</syntaxhighlight>
</lang>
'''Output:'''
<pre>
Line 2,348 ⟶ 2,568:
 
=={{header|NewLISP}}==
<langsyntaxhighlight NewLISPlang="newlisp">;; using the crypto module from http://www.newlisp.org/code/modules/crypto.lsp.html
;; (import native functions from the crypto library, provided by OpenSSL)
(module "crypto.lsp")
(crypto:sha256 "Rosetta Code")</langsyntaxhighlight>
 
=={{header|Nim}}==
Line 2,357 ⟶ 2,577:
Using the third party library <code>nimcrypto</code>, the program is very simple:
 
<langsyntaxhighlight Nimlang="nim">import nimcrypto
 
echo sha256.digest("Rosetta code")</langsyntaxhighlight>
 
{{out}}
Line 2,368 ⟶ 2,588:
{{libheader|OpenSSL}}
 
<langsyntaxhighlight lang="nim">import strutils
 
const SHA256Len = 32
Line 2,380 ⟶ 2,600:
result.add s[i].BiggestInt.toHex(2).toLower
 
echo SHA256("Rosetta code")</langsyntaxhighlight>
 
{{out}}
Line 2,387 ⟶ 2,607:
=={{header|Oberon-2}}==
{{works with|oo2c}}{{libheader|crypto}}
<langsyntaxhighlight lang="oberon2">
MODULE SHA256;
IMPORT
Line 2,406 ⟶ 2,626:
Out.String("SHA256: ");Utils.PrintHex(str,0,h.size);Out.Ln
END SHA256.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,415 ⟶ 2,635:
 
=={{header|Objeck}}==
<syntaxhighlight lang="objeck">
<lang Objeck>
class ShaHash {
function : Main(args : String[]) ~ Nil {
Line 2,424 ⟶ 2,644:
}
}
</syntaxhighlight>
</lang>
<pre>
764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
Line 2,436 ⟶ 2,656:
</pre>
or in XCode.
<langsyntaxhighlight lang="objc">#import <Cocoa/Cocoa.h>
#import <CommonCrypto/CommonDigest.h>
 
Line 2,455 ⟶ 2,675:
return 0;
}
</syntaxhighlight>
</lang>
 
=={{header|OCaml}}==
Line 2,461 ⟶ 2,681:
{{libheader|caml-sha}}
 
<langsyntaxhighlight lang="ocaml">let () =
let s = "Rosetta code" in
let digest = Sha256.string s in
print_endline (Sha256.to_hex digest)</langsyntaxhighlight>
 
Running this script in interpreted mode:
Line 2,476 ⟶ 2,696:
Apple OS X command line with echo and sha256sum.
 
<langsyntaxhighlight lang="sha256sum">echo -n 'Rosetta code' | sha256sum</langsyntaxhighlight>
 
Using the -n flag for echo is required as echo normally outputs a newline.
Line 2,487 ⟶ 2,707:
It works on Linux systems.
 
<langsyntaxhighlight lang="parigp">sha256(s)=extern("echo \"Str(`echo -n '"Str(s)"'|sha256sum|cut -d' ' -f1`)\"")</langsyntaxhighlight>
 
The code above creates a new function sha256(s) which returns SHA-256 hash of item s.
Line 2,497 ⟶ 2,717:
=={{header|Perl}}==
The preferred way to do a task like this is to use an already written module, for example:
<langsyntaxhighlight Perllang="perl">#!/usr/bin/perl
use strict ;
use warnings ;
Line 2,504 ⟶ 2,724:
my $digest = sha256_hex my $phrase = "Rosetta code" ;
print "SHA-256('$phrase'): $digest\n" ;
</syntaxhighlight>
</lang>
{{out}}
<pre>SHA-256('Rosetta code'): 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
Line 2,511 ⟶ 2,731:
On the other hand, one of perl's mottos is There Is More Than One Way To Do It, so of course
you could write your own implementation if you wanted to.
<syntaxhighlight lang="perl">
<lang Perl>
package Digest::SHA256::PP;
 
Line 2,651 ⟶ 2,871:
 
1;
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,659 ⟶ 2,879:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">sha256</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
Line 2,671 ⟶ 2,891:
<span style="color: #0000FF;">?</span><span style="color: #000000;">asHex</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sha256</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Rosetta code"</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,678 ⟶ 2,898:
The standard include file sha256.e is now mainly optimised inline assembly, but the following
is, I feel, more in the spirit of this site
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\sha-256.exw
Line 2,799 ⟶ 3,019:
<span style="color: #0000FF;">?</span><span style="color: #000000;">sha256</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Rosetta code"</span><span style="color: #0000FF;">)</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,806 ⟶ 3,026:
 
=={{header|PHP}}==
<langsyntaxhighlight lang="php"><?php
echo hash('sha256', 'Rosetta code');
</syntaxhighlight>
</lang>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 2,814 ⟶ 3,034:
=={{header|PicoLisp}}==
Library and implementation.
<langsyntaxhighlight PicoLisplang="picolisp">(setq *Sha256-K
(mapcar hex
'("428A2F98" "71374491" "B5C0FBCF" "E9B5DBA5" "3956C25B"
Line 2,973 ⟶ 3,193:
'(NIL (32)) ) ) ) ) )
 
(bye)</langsyntaxhighlight>
 
=={{header|Pike}}==
<syntaxhighlight lang="pike">
<lang Pike>
string input = "Rosetta code";
string out = Crypto.SHA256.hash(input);
write( String.string2hex(out) +"\n");
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 2,988 ⟶ 3,208:
=={{header|PowerShell}}==
{{works with|PowerShell 5.0}}
<syntaxhighlight lang="powershell">
<lang PowerShell>
Set-Content -Value "Rosetta code" -Path C:\Colors\blue.txt -NoNewline -Force
Get-FileHash -Path C:\Colors\blue.txt -Algorithm SHA256
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,001 ⟶ 3,221:
=={{header|PureBasic}}==
PB Version 5.40
<langsyntaxhighlight lang="purebasic">a$="Rosetta code"
bit.i= 256
 
Line 3,008 ⟶ 3,228:
OpenConsole()
Print("[SHA2 "+Str(bit)+" bit] Text: "+a$+" ==> "+b$)
Input()</langsyntaxhighlight>
{{out}}
<pre>[SHA2 256 bit] Text: Rosetta code ==> 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 3,014 ⟶ 3,234:
=={{header|Python}}==
Python has a standard module for this:
<langsyntaxhighlight lang="python">>>> import hashlib
>>> hashlib.sha256( "Rosetta code".encode() ).hexdigest()
'764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf'
>>> </langsyntaxhighlight>
 
=={{header|R}}==
<langsyntaxhighlight lang="rsplus">
library(digest)
 
input <- "Rosetta code"
cat(digest(input, algo = "sha256", serialize = FALSE), "\n")
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 3,032 ⟶ 3,252:
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang racket/base
 
Line 3,053 ⟶ 3,273:
;; use the defined wrapper to solve the task
(displayln (sha256 #"Rosetta code"))
</syntaxhighlight>
</lang>
 
{{out}}
Line 3,063 ⟶ 3,283:
The following implementation takes all data as input. Ideally, input should be given lazily or something.
 
<syntaxhighlight lang="raku" perl6line>say sha256 "Rosetta code";
 
our proto sha256($) returns blob8 {*}
sub init(&f) {
 
map { my $f = $^p.&f; (($f - $f.Int)*2**32).Int },
multi sha256(Str $str) { samewith $str.encode }
state @ = grep *.is-prime, 2 .. *;
multi sha256(blob8 $data) {
}
sub rotr { $^a +> $^b +| $a +< (32 - $b) }
sub infix:<m+>init { ($^aInf +.grep(&is-prime).map: { (($^b)_ %- .Int)*2**32).Int } o &^f }
sub rotr($n, $b) Ch { $n^x +>& $b^y +|^ +^$nx +< (32 -& $b)^z }
sub Maj { $^x +& $^y +^ $x +& $^z +^ $y +& $z }
sub Σ0 { rotr($^x, 2) +^ rotr($x, 13) +^ rotr($x, 22) }
proto sha256($) returns Blob {*}
sub Σ1 { rotr($^x, 6) +^ rotr($x, 11) +^ rotr($x, 25) }
multi sha256(Str $str where all($str.ords) < 128) {
sub σ0 { rotr($^x, 7) +^ rotr($x, 18) +^ $x +> 3 }
sha256 $str.encode: 'ascii'
sub σ1 { rotr($^x, 17) +^ rotr($x, 19) +^ $x +> 10 }
}
 
multi sha256(Blob $data) {
return blob8.new:
constant K = init(* **(1/3))[^64];
map |*.polymod(256 xx 3).reverse,
my @b = flat $data.list, 0x80;
|reduce -> $H, $block {
push @b, 0 until (8 * @b - 448) %% 512;
blob32.new: $H[] Z+
push @b, slip reverse (8 * $data).polymod(256 xx 7);
reduce -> $h, $j {
my @word = :256[@b.shift xx 4] xx @b/4;
my uint32 ($T1, $T2) =
$h[7] + Σ1($h[4]) + Ch(|$h[4..6])
my @H = init(&sqrt)[^8];
+ (BEGIN init(* **(1/3))[^64])[$j] +
my @w;
(
loop (my $i = 0; $i < @word; $i += 16) {
(state buf32 $w .= new)[$j] = $j < 16 ?? $block[$j] !!
my @h = @H;
σ0($w[$j-15]) + $w[$j-7] + σ1($w[$j-2]) + $w[$j-16]
for ^64 -> $j {
),
@w[$j] = $j < 16 ?? @word[$j + $i] // 0 !!
Σ0($h[0]) + Maj(|$h[m+0..2]);
blob32.new: $T1 + $T2, rotr(@w|$h[$j-150..2], 7)$h[3] +^ rotr(@w[$j-15]T1, 18) +^ @w|$h[$j-154..6] +> 3,;
}, @w[$j-7]H, |^64;
},
rotr(@w[$j-2], 17) +^ rotr(@w[$j-2], 19) +^ @w[$j-2] +> 10,
(BEGIN init(&sqrt)[^8]),
@w[$j-16];
|blob32.new(
my $ch = @h[4] +& @h[5] +^ +^@h[4] % 2**32 +& @h[6];
blob8.new(
my $maj = @h[0] +& @h[2] +^ @h[0] +& @h[1] +^ @h[1] +& @h[2];
@$data,
my $σ0 = [+^] map { rotr @h[0], $_ }, 2, 13, 22;
0x80,
my $σ1 = [+^] map { rotr @h[4], $_ }, 6, 11, 25;
0 xx (-($data + 1 my $t1 = [m+] @h[7],8) $σ1,mod $ch64), K[$j], @w[$j];
(8*$data).polymod(256 xx 7).reverse
my $t2 = $σ0 m+ $maj;
).rotor(4)
@h = flat $t1 m+ $t2, @h[^3], @h[3] m+ $t1, @h[4..6];
.map: { :256[@$_] }
).rotor(16)
@H [Z[m+]]= @h;
}</syntaxhighlight>
}
return Blob.new: map { |reverse .polymod(256 xx 3) }, @H;
}</lang>
{{out}}
<pre>BufBlob[uint8]:0x<76 4f4F afAF 5c5C 61 acAC 31 5f5F 14 97 f9F9 dfDF a5A5 42 71 39 65 b7B7 85 e5E5 ccCC 2f2F 70 7d7D 64 68 d7D7 d1D1 12 4c4C dfDF cfCF></pre>
 
=== LibraryNative implementation ===
<syntaxhighlight lang="raku" perl6line>use Digest::SHA256::Native;
 
# If you want a string
Line 3,117 ⟶ 3,335:
 
# If you want a binary Blob
say sha256 'Rosetta code';</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
Line 3,123 ⟶ 3,341:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project: SHA-256
 
Line 3,131 ⟶ 3,349:
see "SHA-256: "
see sha256(str) + nl
</syntaxhighlight>
</lang>
Output:
<pre>
Line 3,139 ⟶ 3,357:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'digest/sha2'
puts Digest::SHA256.hexdigest('Rosetta code')</langsyntaxhighlight>
 
=={{header|Rust}}==
 
<lang rust>use sha2::{Digest, Sha256};
=== Library ===
<syntaxhighlight lang="rust">use sha2::{Digest, Sha256};
 
fn hex_string(input: &[u8]) -> String {
Line 3,168 ⟶ 3,388:
println!("{}", hex);
}
</syntaxhighlight>
</lang>
 
{{out}}
<pre>
764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
</pre>
 
=== Pure Rust ===
<syntaxhighlight lang="rust">const HASH_VALUES: [u32; 8] = [
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
];
 
const ROUND_CONSTANTS: [u32; 64] = [
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
];
 
const INPUT: &str = "Rosetta code";
 
fn main() {
let mut bytes = INPUT.as_bytes().to_vec();
 
let mut hash_values = HASH_VALUES.to_vec();
 
let input_len = bytes.len(); // Bytes
let input_len_byte = (input_len * 8).to_be_bytes(); // Bits
 
let padding = ((64 * ((input_len + 72) / 64)) - input_len) - 9; // Bytes
 
bytes.push(128);
bytes.append(&mut vec![0; padding]);
bytes.extend(input_len_byte);
 
for byte_chunk in bytes.chunks(64) {
let mut working_hash = hash_values.clone();
 
let mut joined_bytes: Vec<u32> = byte_chunk
.chunks(4)
.map(|chunk| u32::from_be_bytes(chunk.try_into().unwrap()))
.collect();
 
joined_bytes.append(&mut vec![0; 48]);
 
// Message loop
 
for i in 16..64 {
let chunk_index_1 = joined_bytes[i - 15];
let chunk_index_2 = joined_bytes[i - 2];
 
let sigma_1 = chunk_index_1.rotate_right(7)
^ chunk_index_1.rotate_right(18)
^ (chunk_index_1 >> 3);
let sigma_2 = chunk_index_2.rotate_right(17)
^ chunk_index_2.rotate_right(19)
^ (chunk_index_2 >> 10);
 
joined_bytes[i] = joined_bytes[i - 16]
.wrapping_add(sigma_1.wrapping_add(joined_bytes[i - 7].wrapping_add(sigma_2)));
}
 
// Compression loop
 
for i in 0..64 {
let sigma_1 = working_hash[4].rotate_right(6)
^ working_hash[4].rotate_right(11)
^ working_hash[4].rotate_right(25);
let choice =
(working_hash[4] & working_hash[5]) ^ ((!working_hash[4]) & working_hash[6]);
let temp_1 = working_hash[7].wrapping_add(sigma_1.wrapping_add(
choice.wrapping_add(ROUND_CONSTANTS[i].wrapping_add(joined_bytes[i])),
));
 
let sigma_0 = working_hash[0].rotate_right(2)
^ working_hash[0].rotate_right(13)
^ working_hash[0].rotate_right(22);
let majority = (working_hash[0] & working_hash[1])
^ (working_hash[0] & working_hash[2])
^ (working_hash[1] & working_hash[2]);
let temp_2 = sigma_0.wrapping_add(majority);
 
working_hash.pop();
working_hash.insert(0, temp_1.wrapping_add(temp_2));
working_hash[4] = working_hash[4].wrapping_add(temp_1);
}
 
hash_values = hash_values
.iter()
.zip(working_hash)
.map(|(hv1, hv2)| hv1.wrapping_add(hv2))
.collect();
}
 
let output: String = hash_values
.iter()
.map(|val| format!("{:08x}", val))
.collect::<Vec<String>>()
.join("");
 
assert_eq!(
output,
"764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"
);
 
println!("{}", output);
}
</syntaxhighlight>
 
{{out}}
Line 3,176 ⟶ 3,507:
 
=={{header|Scala}}==
{{libheader|Scala}}<langsyntaxhighlight Scalalang="scala">object RosettaSHA256 extends App {
 
def MD5(s: String): String = {
Line 3,186 ⟶ 3,517:
assert(MD5("Rosetta code") == "764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf")
println("Successfully completed without errors.")
}</langsyntaxhighlight>
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "msgdigest.s7i";
 
Line 3,195 ⟶ 3,526:
begin
writeln(hex(sha256("Rosetta code")));
end func;</langsyntaxhighlight>
 
{{out}}
Line 3,203 ⟶ 3,534:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var sha = frequire('Digest::SHA');
say sha.sha256_hex('Rosetta code');</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
 
=={{header|Slope}}==
<syntaxhighlight lang="slope">(display (string->sha256 "Rosetta code"))</syntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
Line 3,211 ⟶ 3,547:
Use the [http://smalltalkhub.com/#!/~Cryptography/Cryptography Cryptography] library:
 
<langsyntaxhighlight lang="smalltalk">
(SHA256 new hashStream: 'Rosetta code' readStream) hex.
</syntaxhighlight>
</lang>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">package require sha256
 
puts [sha2::sha256 -hex "Rosetta code"]</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>
 
=={{header|VlangTXR}}==
 
<lang vlang>import crypto.sha256
<pre>1> (sha256 "Rosetta code")
#b'764faf5c61ac315f 1497f9dfa5427139 65b785e5cc2f707d 6468d7d1124cdfcf'</pre>
 
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import crypto.sha256
 
fn main() {
println("${sha256.hexhash('Rosetta code')}")//Rosetta code
 
mut h := sha256.new()
h.write('Rosetta code'.bytes()) ?
println('${h.checksum().map(it.hex()).join('')}')
}</langsyntaxhighlight>
{{out}}
<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf
Line 3,240 ⟶ 3,581:
{{libheader|Wren-crypto}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./crypto" for Sha256
import "./fmt" for Fmt
var strings = [
Line 3,259 ⟶ 3,600:
var hash = Sha256.digest(s)
Fmt.print("$s <== '$0s'", hash, s)
}</langsyntaxhighlight>
 
{{out}}
Line 3,277 ⟶ 3,618:
=={{header|zkl}}==
Uses shared library zklMsgHash.so
<langsyntaxhighlight lang="zkl">var MsgHash=Import("zklMsgHash");
MsgHash.SHA256("Rosetta code")=="764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"</langsyntaxhighlight>
{{out}}
<pre>True</pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/221309...351767"