SHA-256: Difference between revisions

{{task|Checksums}}

 

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

 

; SHA256 ============================================================================

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

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

{{out}}

<pre>String: Rosetta code

SHA-256: 764FAF5C61AC315F1497F9DFA542713965B785E5CC2F707D6468D7D1124CDFCF</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}}==

#include <string.h>

#include <openssl/sha.h>

 

return 0;

 

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

using System.Security.Cryptography;

using System.Text;

}

}

 

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

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

</pre>

 

 

=={{header|FunL}}==

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

Java: "" ~> e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

</pre>

 

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

</pre>

=={{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|Julia}}==

 

using SHA

 

 

 

{{out}}

<pre>

</pre>

 

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

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</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:

$ ocaml -I +sha sha256.cma sha.ml

764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf

</pre>

 

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

 

next if ("1" x $p) =~ /^(11+?)\1+$/;

# The choice to generate h and k instead of hard coding

my $c = $p ** ( 1/3 );

push @k, int( ($c - int $c) * WORD );

 

1;

{{out}}

<pre>

</pre>

 

{{out}}

 

=={{header|PicoLisp}}==

Library and implementation.

(mapcar hex

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

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

 

 

{{out}}

 

=={{header|Python}}==

Python has a standard module for this:

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

'764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf'

 

=={{header|Racket}}==

#lang racket/base

 

;; use the defined wrapper to solve the task

(displayln (sha256 #"Rosetta code"))

 

{{out}}

<pre>764faf5c61ac315f1497f9dfa542713965b785e5cc2f707d6468d7d1124cdfcf</pre>

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

 

 

fn main() {

 

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