Rosetta Code

RIPEMD-160: Difference between revisions

Page Discussion

RIPEMD-160 (view source)

Revision as of 12:36, 2 February 2024

22,008 bytes added ,  4 months ago
m
→‎{{header|Wren}}: Minor tidy
m (syntax highlighting fixup automation)
m (→‎{{header|Wren}}: Minor tidy)
(19 intermediate revisions by 4 users not shown)
Line 185:
{{out}}
<pre>b3be159860842cebaa7174c8fff0aa9e50a5199f</pre>
 
=={{header|C++}}==
<syntaxhighlight lang="c++">
#include <bit>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <sstream>
#include <string>
#include <vector>
 
class RIPEMD160 {
public:
std::string message_digest(const std::string& message) {
std::vector<int64_t> state = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };
 
std::vector<uint8_t> bytes = add_padding(message);
for ( uint64_t i = 0; i < bytes.size() / BLOCK_LENGTH; ++i ) {
std::vector<uint32_t> schedule(16, 0);
for ( uint32_t j = 0; j < BLOCK_LENGTH; ++j ) {
schedule[j / 4] |= ( bytes[i + j] ) << ( j % 4 * 8 );
}
 
int32_t a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];
int32_t aa = state[0], bb = state[1], cc = state[2], dd = state[3], ee = state[4];
int32_t t = 0, tt = 0;
 
for ( uint32_t j = 0; j < 80; ++j ) {
uint32_t jj = j / 16;
t = std::rotl(a + ff(jj + 1, b, c, d) + schedule[RL[j]] + KL[jj], SL[j]) + e;
tt = std::rotl(aa + ff(5 - jj, bb, cc, dd) + schedule[RR[j]] + KR[jj], SR[j]) + ee;
 
a = e; e = d; d = std::rotl(static_cast<uint32_t>(c), 10); c = b; b = t;
aa = ee; ee = dd; dd = std::rotl(static_cast<uint32_t>(cc), 10); cc = bb; bb = tt;
}
 
t = state[1] + c + dd;
state[1] = state[2] + d + ee;
state[2] = state[3] + e + aa;
state[3] = state[4] + a + bb;
state[4] = state[0] + b + cc;
state[0] = t;
}
 
std::stringstream stream;
for ( uint32_t i = 0; i < state.size() * 4; ++i ) {
int8_t byte_value = static_cast<int8_t>(unsigned_right_shift(state[i / 4], i % 4 * 8));
stream << std::setfill('0') << std::setw(2) << std::hex << ( byte_value & 0xff );
}
return stream.str();
}
 
private:
std::vector<uint8_t> add_padding(const std::string& message) {
std::vector<uint8_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<uint8_t>(0x0));
 
const uint64_t bit_length = 8 * message.length();
for ( uint32_t i = 0; i < 8; ++i ) {
bytes.emplace_back(static_cast<uint8_t>( bit_length >> ( 8 * i ) ));
}
return bytes;
}
 
uint32_t ff(const uint32_t& group, const uint32_t& x, const uint32_t& y, const uint32_t& z) {
uint32_t result;
switch ( group ) {
case 1: result = x ^ y ^ z; break;
case 2: result = ( x & y ) | ( ~x & z ); break;
case 3: result = ( x | ~y ) ^ z; break;
case 4: result = ( x & z ) | ( y & ~z ); break;
case 5: result = x ^ ( y | ~z ); break;
default: throw std::invalid_argument("Unexpected argument: " + group);
};
return result;
}
 
int32_t unsigned_right_shift(const int32_t& base, const int32_t& shift) {
if ( shift < 0 || shift >= 32 ) {
throw std::invalid_argument("Shift must be in range 0..31: " + shift);
}
if ( base == 0 ) {
return 0;
}
return ( base > 0 ) ? base >> shift : static_cast<uint32_t>(base) >> shift;
}
 
const std::vector<uint32_t> SR = { 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 };
 
const std::vector<uint32_t> SL = { 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 };
 
const std::vector<uint32_t> RR = { 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 };
 
const std::vector<uint32_t> RL = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 };
 
const std::vector<uint32_t> KL = { 0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e };
const std::vector<uint32_t> KR = { 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000 };
 
const uint32_t BLOCK_LENGTH = 64;
};
 
int main() {
RIPEMD160 ripemd160;
std::cout << ripemd160.message_digest("Rosetta Code") << std::endl;
}
</syntaxhighlight>
{{ out }}
<pre>
b3be159860842cebaa7174c8fff0aa9e50a5199f
</pre>
 
=={{header|Clojure}}==
Line 262 ⟶ 395:
b3be159860842cebaa7174c8fff0aa9e50a5199f
</pre>
 
=={{header|Fortran}}==
{{works with|Fortran|2003}}
 
<syntaxhighlight lang="fortran">program main
use, intrinsic :: iso_c_binding
implicit none
 
integer, parameter :: DIGEST_LEN = 20
integer, parameter :: HASH_LEN = 40
 
interface
function c_ripemd160(d, n, md) bind(c, name='RIPEMD160')
import :: c_char, c_long, c_ptr
implicit none
character(kind=c_char), intent(in) :: d
integer(kind=c_long), intent(in), value :: n
character(kind=c_char), intent(in) :: md
type(c_ptr) :: c_ripemd160
end function c_ripemd160
end interface
 
print '(a)', ripemd160('Rosetta Code')
contains
function ripemd160(str) result(hash)
character(len=*), intent(in) :: str
character(len=HASH_LEN) :: hash
 
character(len=DIGEST_LEN) :: raw
integer :: i
type(c_ptr) :: ptr
 
hash = ' '
ptr = c_ripemd160(str, len(str, kind=c_long), raw)
if (.not. c_associated(ptr)) return
write (hash, '(20z2.2)') (raw(i:i), i = 1, DIGEST_LEN)
end function ripemd160
end program main</syntaxhighlight>
 
{{out}}
<pre>B3BE159860842CEBAA7174C8FFF0AA9E50A5199F</pre>
 
=={{header|FreeBASIC}}==
Line 502 ⟶ 676:
}</syntaxhighlight>
{{out}}
<pre>
b3be159860842cebaa7174c8fff0aa9e50a5199f
</pre>
 
===Without external libraries===
<syntaxhighlight lang="java">
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
 
public final class RIPEMD160Task {
 
public static void main(String[] aArgs) {
System.out.println(RIPEMD160.messageDigest("Rosetta Code"));
}
 
}
 
final class RIPEMD160 {
public static String messageDigest(String aMessage) {
int[] state = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };
byte[] bytes = addPadding(aMessage);
for ( int i = 0; i < bytes.length / BLOCK_LENGTH; i++ ) {
int[] schedule = new int[16];
for ( int j = 0; j < BLOCK_LENGTH; j++ ) {
schedule[j / 4] |= ( bytes[i * BLOCK_LENGTH + j] & 0xff ) << ( j % 4 * 8 );
}
int a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];
int aa = state[0], bb = state[1], cc = state[2], dd = state[3], ee = state[4];
int t = 0, tt = 0;
for ( int j = 0; j < 80; j++ ) {
int jj = j / 16;
t = Integer.rotateLeft(a + ff(jj + 1, b, c, d) + schedule[RL[j]] + KL[jj], SL[j]) + e;
tt = Integer.rotateLeft(aa + ff(5 - jj, bb, cc, dd) + schedule[RR[j]] + KR[jj], SR[j]) + ee;
a = e; e = d; d = Integer.rotateLeft(c, 10); c = b; b = t;
aa = ee; ee = dd; dd = Integer.rotateLeft(cc, 10); cc = bb; bb = tt;
}
t = state[1] + c + dd;
state[1] = state[2] + d + ee;
state[2] = state[3] + e + aa;
state[3] = state[4] + a + bb;
state[4] = state[0] + b + cc;
state[0] = t;
}
String result = "";
for ( int i = 0; i < state.length * 4; i++ ) {
result += String.format("%02x", (byte) ( state[i / 4] >>> ( i % 4 * 8 ) ));
}
return result;
}
private static byte[] addPadding(String aMessage) {
byte[] bytes = aMessage.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 = aMessage.length() * 8;
for ( int i = 0; i < 8; i++ ) {
bytes[bytes.length - 8 + i] = (byte) ( bitLength >>> ( 8 * i ) );
}
return bytes;
}
private static int ff(int aGroup, int aX, int aY, int aZ) {
return switch ( aGroup ) {
case 1 -> aX ^ aY ^ aZ;
case 2 -> ( aX & aY ) | ( ~aX & aZ );
case 3 -> ( aX | ~aY ) ^ aZ;
case 4 -> ( aX & aZ ) | ( aY & ~aZ );
case 5 -> aX ^ ( aY | ~aZ );
default -> throw new IllegalArgumentException("Unexpected argument: " + aGroup);
};
}
private static final int[] KL = new int[] { 0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e };
private static final int[] KR = new int [] { 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000 };
private static final int[] RL = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,
3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,
1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,
4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13 };
private static final int[] RR = new int[] { 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,
6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,
15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,
8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,
12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11 };
private static final int[] SL = new int[] { 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,
7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,
11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,
11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,
9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6 };
private static final int[] SR = new int[] { 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,
9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,
9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,
15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,
8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11 };
private static final int BLOCK_LENGTH = 64;
}
</syntaxhighlight>
{{ out }}
<pre>
b3be159860842cebaa7174c8fff0aa9e50a5199f
Line 780 ⟶ 1,072:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="text">Hash["Rosetta codeCode", "RIPEMD160", "HexString"]</syntaxhighlight>
{{out}}
<pre>1cda558e41e47c3090aafd73ca5651d176f95ca9b3be159860842cebaa7174c8fff0aa9e50a5199f</pre>
 
=={{header|Nim}}==
Line 990 ⟶ 1,282:
 
=={{header|PicoLisp}}==
<syntaxhighlight lang="picolisplisp">(de *R160-R1 . (1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
8 5 14 2 11 7 16 4 13 1 10 6 3 15 12 9
4 11 15 5 10 16 9 2 3 8 1 7 14 12 6 13
Line 1,238 ⟶ 1,530:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>=for# CREDITShttps://github.com/grondilu/libdigest-raku/blob/master/lib/Digest/RIPEMD.rakumod
 
say rmd160 "Rosetta Code";
 
=begin CREDITS
Crypto-JS v2.0.0
http:#code.google.com/p/crypto-js/
Copyright (c) 2009, Jeff Mott. All rights reserved.
=end CREDITS
 
proto rmd160($) returns Blob is export {*}
multi rmd160(Str $str) { samewith $str.encode }
sub rotl($n, $b) { $n +< $b +| $n +> (32 - $b) }
sub prefix:<m^> { +^$^x % 2**32 }
sub infix:<m+> { ($^x + $^y) % 2**32 }
constant r1 = <
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
7 4 13 1 10 6 15 3 12 0 9 5 2 14 11 8
3 10 14 4 9 15 8 1 2 7 0 6 13 11 5 12
1 9 11 10 0 8 12 4 13 3 7 15 14 5 6 2
4 0 5 9 7 12 2 10 14 1 3 8 11 6 15 13
>;
constant r2 = <
5 14 7 0 9 2 11 4 13 6 15 8 1 10 3 12
6 11 3 7 0 13 5 10 14 15 8 12 4 9 1 2
15 5 1 3 7 14 6 9 11 8 12 2 10 0 4 13
8 6 4 1 3 11 15 0 5 12 2 13 9 7 10 14
12 15 10 4 1 5 8 7 6 2 13 14 0 3 9 11
>;
constant s1 = <
11 14 15 12 5 8 7 9 11 13 14 15 6 7 9 8
7 6 8 13 11 9 7 15 7 12 15 9 11 7 13 12
11 13 6 7 14 9 13 15 14 8 13 6 5 12 7 5
11 12 14 15 14 15 9 8 9 14 5 6 8 6 5 12
9 15 5 11 6 8 13 12 5 12 13 14 11 8 5 6
>;
constant s2 = <
8 9 9 11 13 15 15 5 7 7 8 11 14 14 12 6
9 13 15 7 12 8 9 11 7 7 12 7 6 15 13 11
9 7 15 11 8 6 6 14 12 13 5 14 13 13 7 5
15 5 8 11 14 14 6 14 6 9 12 9 12 5 15 8
8 5 12 9 12 5 14 6 8 13 6 5 15 13 11 11
>;
constant F =
* +^ * +^ *,
{ ($^x +& $^y) +| (m^$^x +& $^z) },
(* +| m^*) +^ *,
{ ($^x +& $^z) +| ($^y +& m^$^z) },
* +^ (* +| m^*),
;
constant K1 = flat | <0x00000000 0x5a827999 0x6ed9eba1 0x8f1bbcdc 0xa953fd4e> »xx» 16;
constant K2 = flat | <0x50a28be6 0x5c4dd124 0x6d703ef3 0x7a6d76e9 0x00000000> »xx» 16;
our proto rmd160($) returns Blob {*}
multi rmd160(Str $s) { rmd160 $s.encode: 'ascii' }
multi rmd160(Blob $data) {
 
my @b = | $data, 0x80;
sub rotl(uint32 $n, $b) { $n +< $b +| $n +> (32 - $b) }
push @b, 0 until (8*@b-448) %% 512;
 
my $len = 8 * $data.elems;
blob8.new:
push @b, | gather for ^8 { take $len % 256; $len div= 256 }
map |*.polymod(256 xx 3),
|reduce
my @word = gather for @b -> $a, $b, $c, $d {
-> take reduce * *256 + *,blob32 $dh, $c,@words $b, $a;{
blob32.new: [Z+] map {$_[[^5].rotate(++$)]}, $h, |await
}
map -> [&f, $r, @K, $s] {
start {
my @h = 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0;
loop (my $i = 0; $i < @word; $i += 16)reduce -> $A, $j {
my @X = my @Y = @h; $A[4],
for ^80 -> $j { rotl(
my ($TA[0] =+ rotl(BEGIN [
@X[0] m+ F[$j div 16](|@X[1..3])* m+^ (@word[$i+r1[$j]]* // 0) m+^ K1[$j]*, s1[$j]
) m { $^x +& $^y +| +^$x +& $^z @X[4];},
@X = @X[4], $T, @X[1], rotl (@X[2],* 10+| +^*) %+^ 2**32, @X[3];
{ $T^x =+& $^z +| $^y +& +^$^z rotl(},
@Y[0] m+ F[(79-$j) div 16](|@Y[1..3]){ $^x m+^ (@word[$i^y +r2[$j]]| // 0) m+ K2[^$j],^z) s2[$j]}
])[&f($j) m+div @Y16](|$A[41..3];)
@Y = @Y[4], $T, + @Ywords[1$r[$j]], rotl(+ @YK[2$j], 10) %mod 2**32, @Y[3];
} $s[$j]
@h = (flat @h[1..4,^1]) Z[m+] (flat @X[2..4,^2] ) Z[m+] flat @Y$A[3..4],^3];
$A[1],
}
rotl($A[2], 10),
return Blob.new: gather for @h -> $word is rw {
for ^4 { take $word % 256; $word div= 256 }A[3]
}, $h, |^80
}
}
}
},
BEGIN Array.new:
say rmd160 "Rosetta Code";</syntaxhighlight>
map -> [ &a,$b,@c,$d ] {
[&a,.($b),(flat @c »xx» 16),.($d)] given *.comb».parse-base(16)
},
( +*,
"0123456789ABCDEF74D1A6F3C0952EB83AE49F812706DB5C19BA08C4D37FE56240597C2AE138B6FD",
<0x00000000 0x5a827999 0x6ed9eba1 0x8f1bbcdc 0xa953fd4e>,
"BEFC5879BDEF6798768DB97F7CF9B7DCBD67E9DFE8D65C75BCEFEF989E56865C9F5B68DC5CDEB856"
),
(79-*,
"5E7092B4D6F81A3C6B370D5AEF8C4912F5137E69B8C2A04D86413BF05C2D97AECFA4158762DE039B",
<0x50a28be6 0x5c4dd124 0x6d703ef3 0x7a6d76e9 0x00000000>,
"899BDFF5778BEEC69DF7C89B77C76FDB97FB866ECD5EDD75F58BEE6E69C9C5F885C9C5E68D65FDBB"
)
;
},
(BEGIN blob32.new: 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0),
|blob32.new(
blob8.new(
$data.list,
0x80,
0 xx (-($data.elems + 1 + 8) % 64),
|(8 * $data).polymod: 256 xx 7
).rotor(4).map: { :256[@^x.reverse] }
).rotor(16);
}</syntaxhighlight>
 
{{Out}}
Line 1,732 ⟶ 2,013:
{{out}}
<pre>b3be159860842cebaa7174c8fff0aa9e50a5199f</pre>
 
=={{header|Visual Basic}}==
{{works with|Visual Basic|6}}
{{works with|VBA|7}}
<syntaxhighlight lang="vb">'--- mdRipeMd160.bas
Option Explicit
DefObj A-Z
 
#Const HasPtrSafe = (VBA7 <> 0)
#Const HasOperators = (TWINBASIC <> 0)
 
#If HasPtrSafe Then
Private Declare PtrSafe Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As LongPtr)
Private Declare PtrSafe Function WideCharToMultiByte Lib "kernel32" (ByVal CodePage As Long, ByVal dwFlags As Long, ByVal lpWideCharStr As LongPtr, ByVal cchWideChar As Long, lpMultiByteStr As Any, ByVal cchMultiByte As Long, ByVal lpDefaultChar As Long, ByVal lpUsedDefaultChar As Long) As Long
#Else
Private Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)
Private Declare Function WideCharToMultiByte Lib "kernel32" (ByVal CodePage As Long, ByVal dwFlags As Long, ByVal lpWideCharStr As Long, ByVal cchWideChar As Long, lpMultiByteStr As Any, ByVal cchMultiByte As Long, ByVal lpDefaultChar As Long, ByVal lpUsedDefaultChar As Long) As Long
#End If
 
Private Const LNG_BLOCKSZ As Long = 64
Private Const LNG_ROUNDS As Long = 80
Private Const LNG_HASHSZ As Long = 20
 
Public Type CryptoRipeMd160Context
H0 As Long
H1 As Long
H2 As Long
H3 As Long
H4 As Long
Partial(0 To LNG_BLOCKSZ - 1) As Byte
NPartial As Long
NInput As Currency
End Type
 
Private LNG_R0(0 To LNG_ROUNDS - 1) As Long
Private LNG_R1(0 To LNG_ROUNDS - 1) As Long
Private LNG_S0(0 To LNG_ROUNDS - 1) As Long
Private LNG_S1(0 To LNG_ROUNDS - 1) As Long
 
#If Not HasOperators Then
Private LNG_POW2(0 To 31) As Long
 
Private Function RotL32(ByVal lX As Long, ByVal lN As Long) As Long
'--- RotL32 = LShift(X, n) Or RShift(X, 32 - n)
Debug.Assert lN <> 0
RotL32 = ((lX And (LNG_POW2(31 - lN) - 1)) * LNG_POW2(lN) Or -((lX And LNG_POW2(31 - lN)) <> 0) * LNG_POW2(31)) Or _
((lX And (LNG_POW2(31) Xor -1)) \ LNG_POW2(32 - lN) Or -(lX < 0) * LNG_POW2(lN - 1))
End Function
 
Private Function UAdd32(ByVal lX As Long, ByVal lY As Long) As Long
If (lX Xor lY) >= 0 Then
UAdd32 = ((lX Xor &H80000000) + lY) Xor &H80000000
Else
UAdd32 = lX + lY
End If
End Function
#End If
 
Public Sub CryptoRipeMd160Init(uCtx As CryptoRipeMd160Context)
Dim vElem As Variant
Dim lIdx As Long
If LNG_R0(0) = 0 Then
For Each vElem In Split("0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 7 4 13 1 10 6 15 3 12 0 9 5 2 14 11 8 3 10 14 4 9 15 8 1 2 7 0 6 13 11 5 12 1 9 11 10 0 8 12 4 13 3 7 15 14 5 6 2 4 0 5 9 7 12 2 10 14 1 3 8 11 6 15 13 5 14 7 0 9 2 11 4 13 6 15 8 1 10 3 12 6 11 3 7 0 13 5 10 14 15 8 12 4 9 1 2 15 5 1 3 7 14 6 9 11 8 12 2 10 0 4 13 8 6 4 1 3 11 15 0 5 12 2 13 9 7 10 14 12 15 10 4 1 5 8 7 6 2 13 14 0 3 9 11")
If lIdx < LNG_ROUNDS Then
LNG_R0(lIdx) = vElem
Else
LNG_R1(lIdx - LNG_ROUNDS) = vElem
End If
lIdx = lIdx + 1
Next
lIdx = 0
For Each vElem In Split("11 14 15 12 5 8 7 9 11 13 14 15 6 7 9 8 7 6 8 13 11 9 7 15 7 12 15 9 11 7 13 12 11 13 6 7 14 9 13 15 14 8 13 6 5 12 7 5 11 12 14 15 14 15 9 8 9 14 5 6 8 6 5 12 9 15 5 11 6 8 13 12 5 12 13 14 11 8 5 6 8 9 9 11 13 15 15 5 7 7 8 11 14 14 12 6 9 13 15 7 12 8 9 11 7 7 12 7 6 15 13 11 9 7 15 11 8 6 6 14 12 13 5 14 13 13 7 5 15 5 8 11 14 14 6 14 6 9 12 9 12 5 15 8 8 5 12 9 12 5 14 6 8 13 6 5 15 13 11 11")
If lIdx < LNG_ROUNDS Then
LNG_S0(lIdx) = vElem
Else
LNG_S1(lIdx - LNG_ROUNDS) = vElem
End If
lIdx = lIdx + 1
Next
#If Not HasOperators Then
LNG_POW2(0) = 1
For lIdx = 1 To 30
LNG_POW2(lIdx) = LNG_POW2(lIdx - 1) * 2
Next
LNG_POW2(31) = &H80000000
#End If
End If
With uCtx
.H0 = &H67452301: .H1 = &HEFCDAB89: .H2 = &H98BADCFE: .H3 = &H10325476: .H4 = &HC3D2E1F0
.NPartial = 0
.NInput = 0
End With
End Sub
 
#If HasOperators Then
[ IntegerOverflowChecks (False) ]
#End If
Public Sub CryptoRipeMd160Update(uCtx As CryptoRipeMd160Context, baInput() As Byte, Optional ByVal Pos As Long, Optional ByVal Size As Long = -1)
Static B(0 To 15) As Long
Dim lIdx As Long
Dim lA0 As Long
Dim lB0 As Long
Dim lC0 As Long
Dim lD0 As Long
Dim lE0 As Long
Dim lTemp0 As Long
Dim lK0 As Long
Dim lA1 As Long
Dim lB1 As Long
Dim lC1 As Long
Dim lD1 As Long
Dim lE1 As Long
Dim lTemp1 As Long
Dim lK1 As Long
With uCtx
If Size < 0 Then
Size = UBound(baInput) + 1 - Pos
End If
.NInput = .NInput + Size
If .NPartial > 0 Then
lIdx = LNG_BLOCKSZ - .NPartial
If lIdx > Size Then
lIdx = Size
End If
Call CopyMemory(.Partial(.NPartial), baInput(Pos), lIdx)
.NPartial = .NPartial + lIdx
Pos = Pos + lIdx
Size = Size - lIdx
End If
Do While Size > 0 Or .NPartial = LNG_BLOCKSZ
If .NPartial <> 0 Then
Call CopyMemory(B(0), .Partial(0), LNG_BLOCKSZ)
.NPartial = 0
ElseIf Size >= LNG_BLOCKSZ Then
Call CopyMemory(B(0), baInput(Pos), LNG_BLOCKSZ)
Pos = Pos + LNG_BLOCKSZ
Size = Size - LNG_BLOCKSZ
Else
Call CopyMemory(.Partial(0), baInput(Pos), Size)
.NPartial = Size
Exit Do
End If
'--- RipeMd160 step
lA0 = .H0: lB0 = .H1: lC0 = .H2: lD0 = .H3: lE0 = .H4
lA1 = .H0: lB1 = .H1: lC1 = .H2: lD1 = .H3: lE1 = .H4
For lIdx = 0 To LNG_ROUNDS - 1
Select Case lIdx \ 16
Case 0
lTemp0 = lB0 Xor lC0 Xor lD0
lTemp1 = lB1 Xor (lC1 Or Not lD1)
lK0 = 0: lK1 = &H50A28BE6
Case 1
lTemp0 = (lB0 And lC0) Or (Not lB0 And lD0)
lTemp1 = (lB1 And lD1) Or (lC1 And Not lD1)
lK0 = &H5A827999: lK1 = &H5C4DD124
Case 2
lTemp0 = (lB0 Or Not lC0) Xor lD0
lTemp1 = (lB1 Or Not lC1) Xor lD1
lK0 = &H6ED9EBA1: lK1 = &H6D703EF3
Case 3
lTemp0 = (lB0 And lD0) Or (lC0 And Not lD0)
lTemp1 = (lB1 And lC1) Or (Not lB1 And lD1)
lK0 = &H8F1BBCDC: lK1 = &H7A6D76E9
Case 4
lTemp0 = lB0 Xor (lC0 Or Not lD0)
lTemp1 = lB1 Xor lC1 Xor lD1
lK0 = &HA953FD4E: lK1 = 0
End Select
#If HasOperators Then
lTemp0 += lA0 + B(LNG_R0(lIdx)) + lK0
lTemp0 = (lTemp0 << LNG_S0(lIdx) Or lTemp0 >> (32 - LNG_S0(lIdx))) + lE0
lTemp1 += lA1 + B(LNG_R1(lIdx)) + lK1
lTemp1 = (lTemp1 << LNG_S1(lIdx) Or lTemp1 >> (32 - LNG_S1(lIdx))) + lE1
#Else
lTemp0 = UAdd32(RotL32(UAdd32(UAdd32(UAdd32(lTemp0, lA0), B(LNG_R0(lIdx))), lK0), LNG_S0(lIdx)), lE0)
lTemp1 = UAdd32(RotL32(UAdd32(UAdd32(UAdd32(lTemp1, lA1), B(LNG_R1(lIdx))), lK1), LNG_S1(lIdx)), lE1)
#End If
lA0 = lE0: lA1 = lE1
lE0 = lD0: lE1 = lD1
#If HasOperators Then
lD0 = (lC0 << 10 Or lC0 >> 22): lD1 = (lC1 << 10 Or lC1 >> 22)
#Else
lD0 = RotL32(lC0, 10): lD1 = RotL32(lC1, 10)
#End If
lC0 = lB0: lC1 = lB1
lB0 = lTemp0: lB1 = lTemp1
Next
#If HasOperators Then
lTemp0 = .H1 + lC0 + lD1
.H1 = .H2 + lD0 + lE1
.H2 = .H3 + lE0 + lA1
.H3 = .H4 + lA0 + lB1
.H4 = .H0 + lB0 + lC1
.H0 = lTemp0
#Else
lTemp0 = UAdd32(UAdd32(.H1, lC0), lD1)
.H1 = UAdd32(UAdd32(.H2, lD0), lE1)
.H2 = UAdd32(UAdd32(.H3, lE0), lA1)
.H3 = UAdd32(UAdd32(.H4, lA0), lB1)
.H4 = UAdd32(UAdd32(.H0, lB0), lC1)
.H0 = lTemp0
#End If
Loop
End With
End Sub
 
Public Sub CryptoRipeMd160Finalize(uCtx As CryptoRipeMd160Context, baOutput() As Byte)
Static B(0 To 4) As Long
Dim P(0 To LNG_BLOCKSZ + 9) As Byte
Dim lSize As Long
With uCtx
lSize = LNG_BLOCKSZ - .NPartial
If lSize < 9 Then
lSize = lSize + LNG_BLOCKSZ
End If
P(0) = &H80
.NInput = .NInput / 10000@ * 8
Call CopyMemory(P(lSize - 8), .NInput, 8)
CryptoRipeMd160Update uCtx, P, Size:=lSize
Debug.Assert .NPartial = 0
B(0) = .H0: B(1) = .H1: B(2) = .H2: B(3) = .H3: B(4) = .H4
ReDim baOutput(0 To LNG_HASHSZ - 1) As Byte
Call CopyMemory(baOutput(0), B(0), UBound(baOutput) + 1)
End With
End Sub
 
Public Function CryptoRipeMd160ByteArray(baInput() As Byte, Optional ByVal Pos As Long, Optional ByVal Size As Long = -1) As Byte()
Dim uCtx As CryptoRipeMd160Context
CryptoRipeMd160Init uCtx
CryptoRipeMd160Update uCtx, baInput, Pos, Size
CryptoRipeMd160Finalize uCtx, CryptoRipeMd160ByteArray
End Function
 
Private Function ToUtf8Array(sText As String) As Byte()
Const CP_UTF8 As Long = 65001
Dim baRetVal() As Byte
Dim lSize As Long
lSize = WideCharToMultiByte(CP_UTF8, 0, StrPtr(sText), Len(sText), ByVal 0, 0, 0, 0)
If lSize > 0 Then
ReDim baRetVal(0 To lSize - 1) As Byte
Call WideCharToMultiByte(CP_UTF8, 0, StrPtr(sText), Len(sText), baRetVal(0), lSize, 0, 0)
Else
baRetVal = vbNullString
End If
ToUtf8Array = baRetVal
End Function
 
Private Function ToHex(baData() As Byte) As String
Dim lIdx As Long
Dim sByte As String
ToHex = String$(UBound(baData) * 2 + 2, 48)
For lIdx = 0 To UBound(baData)
sByte = LCase$(Hex$(baData(lIdx)))
If Len(sByte) = 1 Then
Mid$(ToHex, lIdx * 2 + 2, 1) = sByte
Else
Mid$(ToHex, lIdx * 2 + 1, 2) = sByte
End If
Next
End Function
 
Public Function CryptoRipeMd160Text(sText As String) As String
CryptoRipeMd160Text = ToHex(CryptoRipeMd160ByteArray(ToUtf8Array(sText)))
End Function
</syntaxhighlight>
<syntaxhighlight lang="vb">Debug.Print CryptoRipeMd160Text("Rosetta code")</syntaxhighlight>
{{out}}
<pre>1cda558e41e47c3090aafd73ca5651d176f95ca9</pre>
 
=={{header|Wren}}==
{{libheader|Wren-crypto}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="ecmascriptwren">import "./crypto" for Ripemd160
import "./fmt" for Fmt
var strings = [
PureFox
9,483

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/328231...351528"