SHA-1: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program sha1_64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

{{works with|GNAT}}

 

with GNAT.SHA1;

 

Ada.Text_IO.Put_Line ("SHA1 (""Rosetta Code"") = " &

GNAT.SHA1.Digest ("Rosetta Code"));

 

{{out}}

{{works with|as|Raspberry Pi}}

<B>with openssl library </B>

 

/* ARM assembly Raspberry PI */

/***************************************************/

.include "../affichage.inc"

<B>with only instructions assembly ARM</B>

/* ARM assembly Raspberry PI */

/* program sha1.s */

.include "../affichage.inc"

 

{{Output}}

<pre>

=={{header|Arturo}}==

 

 

{{out}}

 

=={{header|Astro}}==

let hash = sha1.hexdigest('Ars longa, vita brevis')

print hash

 

=={{header|AutoHotkey}}==

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

MsgBox, % "String:`n" (str) "`n`nSHA:`n" SHA(str)

 

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

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

{{out}}

<pre>String: Rosetta Code

===Library===

{{works with|BBC BASIC for Windows}}

END

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

NEXT

{{out}}

<pre>

===Native===

{{works with|BBC BASIC for Windows}}

PRINT FNsha1("Rosetta Code")

END

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

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

{{out}}

<pre>

=={{header|C}}==

{{libheader|OpenSSL}}

#include <stdlib.h>

#include <string.h>

return EXIT_SUCCESS;

 

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

Tests the built-in SHA1CryptoServiceProvider:

using System.Security.Cryptography;

using System.Text;

}

}

 

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

{{libheader|Poco}}

Compiling with <code>g++ -lPocoCrypto shaexample.cpp -o shaexample</code>:

#include <iostream>

#include "Poco/SHA1Engine.h"

<< " !" << std::endl ;

return 0 ;

{{out}}

<pre>Rosetta Code as a sha1 digest :48c98f7e5a6e736d790ab740dfc3f51a61abe2b5 !</pre>

 

This example uses the [http://method-combination.net/lisp/ironclad/ Ironclad] cryptography library (available via Quicklisp as well).

(defun sha1-hash (data)

(let ((sha1 (ironclad:make-digest 'ironclad:sha1))

(ironclad:update-digest sha1 bin-data)

(ironclad:byte-array-to-hex-string (ironclad:produce-digest sha1))))

 

=={{header|Crystal}}==

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

'''First:''' Use native 'std.digest.sha' library

{{trans|Python}}

import std.stdio, std.digest.sha;

 

writefln("%-(%02x%)", "Ars longa, vita brevis".sha1Of);

{{out}}

<pre>e640d285242886eb96ab80cbf858389b3df52f43</pre>

 

'''Second:''' Re-implement SHA-1 in D

std.range, std.digest.sha;

 

void main() {

writeln(sha1("Rosetta Code".dup));

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

{{libheader| System.SysUtils}}

{{libheader| DCPsha1}} Part of '''DCPcrypt Cryptographic Component Library v2.1'''[https://bitbucket.org/wpostma/dcpcrypt2010] by David Barton.

program Sha_1;

 

Writeln(SHA1('Rosetta Code'));

readln;

{{out}}

<pre>

</pre>

=={{header|DWScript}}==

 

{{out}}

Uses Erlang module 'crypto'

{{trans|Erlang}}

iex(1)> :crypto.hash(:sha, "A string")

<<110, 185, 174, 8, 151, 66, 9, 104, 174, 225, 10, 43, 9, 92, 82, 190, 197, 150,

224, 92>>

 

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

(sha1 "Rosetta Code") ;=> "48c98f7e5a6e736d790ab740dfc3f51a61abe2b5"

(secure-hash 'sha1 "Rosetta Code") ;=> "48c98f7e5a6e736d790ab740dfc3f51a61abe2b5"

 

=={{header|Erlang}}==

 

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

let n = System.Security.Cryptography.SHA1.Create()

Array.iter (printf "%x ") (n.ComputeHash "Rosetta Code"B)

{{out}}

<pre>

Using Windows API. See [https://msdn.microsoft.com/en-us/library/aa379886.aspx CryptAcquireContext], [https://msdn.microsoft.com/en-us/library/aa379908.aspx CryptCreateHash], [https://msdn.microsoft.com/en-us/library/aa380202.aspx CryptHashData] and [https://msdn.microsoft.com/en-us/library/aa379947.aspx CryptGetHashParam] on MSDN.

 

use kernel32

use advapi32

deallocate(name)

end do

 

=={{header|FreeBASIC}}==

' started with SHA-1/FIPS-180-1

' but used the BBC BASIC native version to finish.

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>Rosetta Code => 48C98F7E5A6E736D790AB740DFC3F51A61ABE2B5</pre>

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

SHA-1, being overtaken, is not recommended but is supported in GLib checksum, ''ChecksumType.SHA1''.

 

 

(The -1 is NUL byte terminated string indicator for length)

 

=={{header|Go}}==

 

import (

h.Write([]byte("Rosetta Code"))

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

{{out}}

<pre>

 

=={{header|Halon}}==

{{out}}

<pre>

 

=={{header|Hare}}==

use encoding::hex;

use fmt;

hex::encode(os::stdout, sum)!;

fmt::println()!;

{{out}}

<pre>

 

=={{header|Haskell}}==

where

import Data.Digest.Pure.SHA

putStr "Rosetta Code SHA1-codiert: "

putStrLn $ convertToSHA1 "Rosetta Code"

{{Out}}

<pre>

 

=={{header|Haxe}}==

 

class Main {

Sys.println(sha1);

}

 

{{out}}

=={{header|J}}==

From J8 the <tt>ide/qt</tt> addon includes bindings to the Qt library function for a number of hash algorithms incluing SHA-1. Thus:

getsha1=: 'sha1'&gethash_jqtide_

getsha1 'Rosetta Code'

 

From J8.06, the sha family of hashes have builtin support.

 

sha1'Rosetta Code'

 

A implementation of SHA-1 in J follows:

 

 

f=:4 :0

)

 

 

Example use:

 

bits2hex=: '0123456789abcdef' {~ _4 #.\ ,

 

bits2hex sha1 text2bits 'Rosetta Code'

 

Remember that SHA-1 is an obsolete standard (and if you *really* want high speed you'd probably be using [[wp:Application-specific_integrated_circuit|ASICs]] rather than a general purpose computing platform).

 

=={{header|Jsish}}==

var str = 'Rosetta code';

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

b18c883f4da750164b5af362ea9b9f27f90904b4

=!EXPECTEND!=

 

{{out}}

{{works with|Julia|0.6}}

 

 

testdict = Dict("abc" => "a9993e364706816aba3e25717850c26c9cd0d89d",

if length(text) > 50 text = text[1:50] * "..." end

println("# $text\n -> digest: $digest\n -> expect: $expect")

 

{{out}}

 

=={{header|Kotlin}}==

 

import java.security.MessageDigest

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

println()

 

{{out}}

 

=={{header|Lasso}}==

 

{{out}}

 

=={{header|Liberty BASIC}}==

'--------------------------------------------------------------------------------

' FAST SHA1 CALCULATION BASED ON MS ADVAPI32.DLL BY CRYPTOMAN '

next

end function

{{Out}}

<pre>48C98F7E5A6E736D790AB740DFC3F51A61ABE2B5</pre>

=={{header|Lingo}}==

{{libheader|Crypto Xtra}}

{{out}}

<pre>-- "48c98f7e5a6e736d790ab740dfc3f51a61abe2b5"</pre>

 

=={{header|LiveCode}}==

local shex, sha1

put sha1Digest("Rosetta Code") into sha1

get binaryDecode("H*",sha1,shex)

put shex

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

{{libheader|sha1}} ([https://github.com/kikito/sha1.lua luarocks install sha1])

 

 

local sha1 = require "sha1"

for i, str in ipairs{"Rosetta code", "Rosetta Code"} do

print(string.format("SHA-1(%q) = %s", str, sha1(str)))

 

{{out}}

=={{header|Maple}}==

 

Hash("Ars longa, vita brevis",method="SHA1");

 

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

=={{header|min}}==

{{works with|min|0.19.6}}

{{out}}

<pre>

SHA-1 was added in Neko 2.2.

 

SHA-1 in Neko

Tectonics:

 

/* Output in lowercase hex */

 

{{out}}

=={{header|NetRexx}}==

This solution is basically the same as that for [[MD5#NetRExx|MD5]], substituting "SHA-1" for "MD5" as the algorithm to use in the <tt>MessageDigest</tt> instance.

options replace format comments java crossref savelog symbols binary

 

return digestSum

{{out}}

<pre>

 

=={{header|NewLISP}}==

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

(module "crypto.lsp")

 

=={{header|Nim}}==

Nim standard library provides the module “std/sha1” to compute SHA1 digests.

 

 

 

{{out}}

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

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

MODULE SHA1;

IMPORT

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

END SHA1.

{{out}}

<pre>

Using the library <code>ocaml-sha</code> in the interactive loop:

 

Objective Caml version 3.12.1

 

# Sha1.to_hex (Sha1.string "Rosetta Code") ;;

 

=={{header|Octave}}==

Normally SHA-1 is available in the [http://octave.sourceforge.net/general/function/SHA1.html general package].

 

{{out}}

<pre>ans = 48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

It works on Linux systems.

 

 

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

=={{header|Pascal}}==

{{works with|Free_Pascal}} {{libheader|sha1}}

uses

sha1;

d:=SHA1String('Rosetta Code');

WriteLn(SHA1Print(d));

 

{{out}}

=={{header|Perl}}==

{{libheader|Digest::SHA}}

 

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

 

The same in OO manner

 

my $sha1 = Digest::SHA->new(1);

$sha1->add('Rosetta Code');

 

=={{header|Phix}}==

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\sha1.exw

<span style="color: #0000FF;">?</span><span style="color: #000000;">sha1</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Rosetta Code"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|PHP}}==

$string = 'Rosetta Code';

echo sha1( $string ), "\n";

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

=={{header|PicoLisp}}==

Library and implementation.

(| (mod32 (>> (- C) X)) (>> (- 32 C) X)) )

 

'(NIL (20)) ) ) ) ) )

 

=={{header|Pike}}==

string input = "Rosetta Code";

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

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

{{Out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

 

=={{header|PowerShell}}==

Function Calculate-SHA1( $String ){

$Enc = [system.Text.Encoding]::UTF8

[System.Convert]::ToBase64String($Result)

}

taken from [http://stackoverflow.com/questions/8051713/convert-a-string-to-a-byte-array-in-powershell-version-2 Stackoverflow] with a little modification

 

=={{header|PureBasic}}==

PB Version 5.40

 

UseSHA1Fingerprint() : b$=StringFingerprint(a$, #PB_Cipher_SHA1)

OpenConsole()

Print("[SHA1] Text: "+a$+" ==> "+b$)

{{out}}

<pre>[SHA1] Text: Rosetta Code ==> 48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

 

=={{header|Python}}==

h = hashlib.sha1()

h.update(bytes("Ars longa, vita brevis", encoding="ASCII"))

h.hexdigest()

 

=={{header|R}}==

library(digest)

 

input <- "Rosetta Code"

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

{{out}}

<pre>

With the built-in <tt>file/sha1</tt> library:

 

#lang racket

(require file/sha1)

(sha1 (open-input-string "Rosetta Code"))

 

With the faster <tt>openssl/sha1</tt> library (requires OpenSSL to be installed):

 

#lang racket

(require openssl/sha1)

(sha1 (open-input-string "Rosetta Code"))

 

=={{header|Raku}}==

A pure Raku implementation that closely follows the description of SHA-1 in FIPS 180-1. Slow.

 

sub infix:<⊕> { ($^x + $^y)mod2³² }

sub S { ($^x +< $^n)mod2³² +| ($x +> (32-$n)) }

'abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq',

'Rosetta Code',

{{Out}}

<pre>Buf:0x<a9 99 3e 36 47 06 81 6a ba 3e 25 71 78 50 c2 6c 9c d0 d8 9d> abc

===Library based implementation===

Quite speedy.

 

# use sha1-hex() if you want a hex string

'Rosetta Code',

'Ars longa, vita brevis'

{{Out}}

<pre>Blob:0x<A9 99 3E 36 47 06 81 6A BA 3E 25 71 78 50 C2 6C 9C D0 D8 9D> abc

 

=={{header|Ring}}==

# Project : SHA-1

 

see "SHA-1: "

see sha1(str) + nl

Output:

<pre>

 

'''First:''' Use 'digest' from Ruby's standard library.

 

'''Second:''' Use 'openssl' from Ruby's standard library. {{libheader|OpenSSL}}

 

'''Third:''' Reimplement SHA-1 in Ruby.

 

# Calculates SHA-1 message digest of _string_. Returns binary digest.

'Rosetta Code',

].each {|s| printf("%s:\n %s\n", s, *sha1(s).unpack('H*'))}

{{out}}

<pre>

=={{header|Rust}}==

Using sha1 crate: https://docs.rs/sha1/0.6.0/sha1/

 

fn main() {

println!("{}", hash_msg.digest().to_string());

}

Output

<pre>

Support for MD5 and SHA-1 are included in the standard "chksum" library:

 

 

{{out}}

The solution to this task would be a small modification to [[MD5#Scala|MD5]] (replacing "MD5" with "SHA-1" as noted [http://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#MessageDigest here]).

 

import java.nio._

 

println(hash("Rosetta Code"))

}

 

{{out}}

{{works with|Ol}}

 

; band - binary AND operation

; bor - binary OR operation

(->32 (+ D d))

(->32 (+ E e)))))))))

 

{{out}}

(define (->string value)

(runes->string

(print (->string (sha1:digest "")))

> da39a3ee5e6b4b0d3255bfef95601890afd80709

 

=={{header|Seed7}}==

include "msgdigest.s7i";

 

begin

writeln(hex(sha1("Rosetta Code")));

 

{{out}}

 

=={{header|Sidef}}==

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

{{works with|Smalltalk/X}}

 

=={{header|Tcl}}==

{{tcllib|sha1}}

{{out}}

<pre>48c98f7e5a6e736d790ab740dfc3f51a61abe2b5</pre>

=={{header|UNIX Shell}}==

{{works with|OpenBSD|2.2 [http://www.openbsd.org/cgi-bin/cvsweb/src/bin/md5/Makefile (link)]}}

 

{{libheader|OpenSSL}}

 

=={{header|Vlang}}==

 

fn main() {

h.write('Rosetta Code'.bytes()) ?

println('${h.checksum().map(it.hex()).join('')}')

{{out}}

<pre>

{{libheader|Wren-crypto}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

var hash = Sha1.digest(s)

Fmt.print("$s <== '$0s'", hash, s)

 

{{out}}

=={{header|zkl}}==

Using zklMsgHash so. Can return the hash as a string of hex digits or bytes, can hash the hash N times.

zkl: var MsgHash=Import("zklMsgHash")

MsgHash

 

zkl: MsgHash.SHA1("a"*1000,1000); // hash 1000 a's 1000 times