SHA-256: Difference between revisions

 

Either by using a dedicated library or implementing the algorithm in your language, show that the SHA-256 digest of the string "Rosetta code" is: 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

 

=={{header|Ada}}==

{{libheader|CryptAda}}

 

with CryptAda.Pragmatics;

Ada.Text_IO.Put_Line

("""" & Text & """: " & CryptAda.Utils.Format.To_Hex_String (Hashes.Get_Bytes (Hash)));

{{out}}

<pre>"Rosetta code": 764FAF5C61AC315F1497F9DFA542713965B785E5CC2F707D6468D7D1124CDFCF</pre>

 

=={{header|AutoHotkey}}==

Source: [https://github.com/jNizM/AutoHotkey_Scripts/tree/master/Functions/Checksums SHA-256 @github] by jNizM

MsgBox, % "File:`n" (file) "`n`nSHA-256:`n" FileSHA256(file)

 

StrPut(string, &data, floor(length / chrlength), encoding)

return CalcAddrHash(&data, length, algid, hash, hashlength)

{{out}}

<pre>String: Rosetta code

=={{header|AWK}}==

Using the system function as a 'library'.

("echo -n " $0 " | sha256sum") | getline sha;

gsub(/[^0-9a-zA-Z]/, "", sha);

print sha;

}

 

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

PRAGMA LDFLAGS -lcrypto

 

NEXT

 

{{out}}

<pre>

</pre>

 

{{works with|BBC BASIC for Windows}}

END

hash$ += RIGHT$("0" + STR$~buffer%?i%, 2)

NEXT

<pre>

764FAF5C61AC315F1497F9DFA542713965B785E5CC2F707D6468D7D1124CDFCF

</pre>

 

{{works with|BBC BASIC for Windows}}

REM Must run in FLOAT64 mode:

WHILE n# > &7FFFFFFF : n# -= 2^32 : ENDWHILE

WHILE n# < &80000000 : n# += 2^32 : ENDWHILE

<pre>

764FAF5C 61AC315F 1497F9DF A5427139 65B785E5 CC2F707D 6468D7D1 124CDFCF

=={{header|C}}==

Requires OpenSSL, compile flag: <code>-lssl -lcrypto</code>

#include <string.h>

#include <openssl/sha.h>

 

return 0;

 

=={{header|C sharp}}==

using System.Security.Cryptography;

using System.Text;

}

}

 

=={{header|C++}}==

Uses [https://www.cryptopp.com/ crypto++]. Compile it with -lcryptopp

 

#include <cryptopp/filters.h>

#include <cryptopp/hex.h>

return 0;

}

 

=={{header|Caché ObjectScript}}==

=={{header|Clojure}}==

{{libheader|pandect}}

 

{{Out}}

=={{header|Common Lisp}}==

{{libheader|Ironclad}}

(defun sha-256 (str)

(ironclad:byte-array-to-hex-string

(ironclad:ascii-string-to-byte-array str))))

 

 

{{Out}}

<pre>"764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf"</pre>

 

=={{header|D}}==

===Standard Version===

import std.stdio, std.digest.sha;

 

writefln("%-(%02x%)", "Rosetta code".sha256Of);

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

===Simple Implementation===

// Translated to D language. Only lightly tested, not for serious use.

 

pure nothrow @nogc in {

assert(inBuffer.length % 64 == 0);

// Round functions.

static uint F1(in uint e, in uint f, in uint g) pure nothrow @safe @nogc {

writefln("%(%02x%)", SHA256.digest(data));

}

Compile with -version=sha_256_main to run the main function.

{{out}}

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|DWScript}}==

 

=={{header|Emacs Lisp}}==

 

=={{header|Erlang}}==

 

=={{header|F_Sharp|F#}}==

open System.Text

 

|> System.BitConverter.ToString

|> printfn "%s"

{{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

=={{header|Factor}}==

{{works with|Factor|0.98}}

 

{{out}}

<pre>

764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

</pre>

 

764FAF5C61AC315F1497F9DFA542713965B785E5CC2F707D6468D7D1124CDFCF rc.txt (12 bytes)</pre>

 

use kernel32

use advapi32

deallocate(name)

end do

 

=={{header|Free Pascal}}==

 

uses

writeln(lowerCase(output));

 

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

=={{header|FreeBASIC}}==

' FIPS PUB 180-4

' compile with: fbc -s console

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Rosetta code => 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

=={{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.

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

A SHA-256 function can be defined using the Java support library.

 

 

 

Here is a definition implemented as a direct translation of the pseudocode at '''[[wp:SHA-256|SHA-256]]'''.

 

//Initialize hash values

h0 = 0x6a09e667

 

// Produce the final hash value (big-endian)

 

Here is a test comparing the two and also verifying the hash values of the empty message string.

 

 

println( 'FunL: "' + message + '" ~> ' + sha256(message) )

 

println( 'FunL: "' + message + '" ~> ' + sha256(message) )

 

{{out}}

 

=={{header|Genie}}==

/*

SHA-256 in Genie

print digest

 

 

{{out}}

 

=={{header|Go}}==

 

import (

}

fmt.Printf("%x\n", h.Sum(nil))

{{out}}

<pre>

 

=={{header|Groovy}}==

java.security.MessageDigest.getInstance("SHA-256").digest(text.bytes)

.collect { String.format("%02x", it) }.join('')

Testing

 

=={{header|Halon}}==

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

=={{header|Haskell}}==

import Crypto.Hash.SHA256 (hash)

import Data.ByteString (unpack, pack)

map (fromIntegral.ord) -- to array of Word8

"Rosetta code"

{{out}}

<pre style="font-size:80%">764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

 

=={{header|Haxe}}==

 

class Main {

Sys.println(sha256);

}

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

'''Solution:'''

From J8 the <tt>ide/qt</tt> addon provides bindings to Qt libraries that include support for various hashing algorithms including SHA-256.

'''Example Usage:'''

 

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.

Starting in J8.06, the sha family of hashes have built-in support.

 

 

 

=={{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]).

 

=={{header|JavaScript}}==

const crypto = require('crypto');

 

 

console.log(hash);

{{out}}

<pre>

 

=={{header|Jsish}}==

var str = 'Rosetta code';

puts(Util.hash(str, {type:'sha256'}));

764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

 

using Nettle

digest1 = join(num2hex.(sha256(msg)))

 

 

=={{header|Kotlin}}==

 

import java.security.MessageDigest

for (byte in digest) print("%02x".format(byte))

println()

 

{{out}}

Use the cipher_list method to view these algorithms.

 

// algorithms supported by the installation of Lasso

cipher_list

// return the SHA-256 digest. Dependant on SHA-256 being an available digest method

cipher_digest('Rosetta Code', -digest='SHA-256',-hex=true)

 

=={{header|Lua}}==

{{libheader|sha2}} ([http://code.google.com/p/sha2/ luarocks install sha2])

 

 

require "sha2"

 

 

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

=={{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.

options replace format comments java crossref savelog symbols binary

 

return digestSum

'''Output:'''

<pre>

 

=={{header|NewLISP}}==

;; (import native functions from the crypto library, provided by OpenSSL)

(module "crypto.lsp")

 

=={{header|Nim}}==

{{libheader|OpenSSL}}

 

const SHA256Len = 32

result = ""

let s = SHA256(s.cstring, s.len.culong)

result.add s[i].BiggestInt.toHex(2).toLower

 

 

{{out}}

=={{header|Oberon-2}}==

{{works with|oo2c}}{{libheader|crypto}}

MODULE SHA256;

IMPORT

Out.String("SHA256: ");Utils.PrintHex(str,0,h.size);Out.Ln

END SHA256.

{{out}}

<pre>

 

=={{header|Objeck}}==

class ShaHash {

function : Main(args : String[]) ~ Nil {

}

}

<pre>

764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

</pre>

or in XCode.

#import <CommonCrypto/CommonDigest.h>

 

return 0;

}

 

=={{header|OCaml}}==

{{libheader|caml-sha}}

 

let s = "Rosetta code" in

let digest = Sha256.string s in

 

Running this script in interpreted mode:

Apple OS X command line with echo and sha256sum.

 

 

Using the -n flag for echo is required as echo normally outputs a newline.

It works on Linux systems.

 

 

The code above creates a new function sha256(s) which returns SHA-256 hash of item s.

=={{header|Perl}}==

The preferred way to do a task like this is to use an already written module, for example:

use strict ;

use warnings ;

my $digest = sha256_hex my $phrase = "Rosetta code" ;

print "SHA-256('$phrase'): $digest\n" ;

{{out}}

<pre>SHA-256('Rosetta code'): 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

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.

package Digest::SHA256::PP;

 

 

1;

{{out}}

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

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

{{out}}

<pre>

 

=={{header|PHP}}==

echo hash('sha256', 'Rosetta code');

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

=={{header|PicoLisp}}==

Library and implementation.

(mapcar hex

'("428A2F98" "71374491" "B5C0FBCF" "E9B5DBA5" "3956C25B"

'(NIL (32)) ) ) ) ) )

 

 

=={{header|Pike}}==

string input = "Rosetta code";

string out = Crypto.SHA256.hash(input);

write( String.string2hex(out) +"\n");

{{Out}}

<pre>

=={{header|PowerShell}}==

{{works with|PowerShell 5.0}}

Set-Content -Value "Rosetta code" -Path C:\Colors\blue.txt -NoNewline -Force

Get-FileHash -Path C:\Colors\blue.txt -Algorithm SHA256

{{out}}

<pre>

=={{header|PureBasic}}==

PB Version 5.40

bit.i= 256

 

OpenConsole()

Print("[SHA2 "+Str(bit)+" bit] Text: "+a$+" ==> "+b$)

{{out}}

<pre>[SHA2 256 bit] Text: Rosetta code ==> 764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

=={{header|Python}}==

Python has a standard module for this:

>>> hashlib.sha256( "Rosetta code".encode() ).hexdigest()

'764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf'

 

=={{header|R}}==

library(digest)

 

input <- "Rosetta code"

cat(digest(input, algo = "sha256", serialize = FALSE), "\n")

{{out}}

<pre>

 

=={{header|Racket}}==

#lang racket/base

 

;; use the defined wrapper to solve the task

(displayln (sha256 #"Rosetta code"))

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

The following implementation takes all data as input. Ideally, input should be given lazily or something.

 

 

{{out}}

 

 

# If you want a string

 

# If you want a binary Blob

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

 

=={{header|Ring}}==

# Project: SHA-256

 

see "SHA-256: "

see sha256(str) + nl

Output:

<pre>

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

 

fn hex_string(input: &[u8]) -> String {

 

// write input message

 

// read hash digest and consume hasher

 

let hex = hex_string(&result);

);

}

 

{{out}}

 

=={{header|Scala}}==

 

def MD5(s: String): String = {

assert(MD5("Rosetta code") == "764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf")

println("Successfully completed without errors.")

 

=={{header|Seed7}}==

include "msgdigest.s7i";

 

begin

writeln(hex(sha256("Rosetta code")));

 

{{out}}

 

=={{header|Sidef}}==

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

Use the [http://smalltalkhub.com/#!/~Cryptography/Cryptography Cryptography] library:

 

(SHA256 new hashStream: 'Rosetta code' readStream) hex.

 

=={{header|Tcl}}==

 

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

=={{header|zkl}}==

Uses shared library zklMsgHash.so

{{out}}

<pre>True</pre>