Data update
This commit is contained in:
Ingy döt Net
parent
4d5544505c
commit
4924dd0264
3073 changed files with 55820 additions and 4408 deletions
|
|
@ -4,16 +4,16 @@
|
|||
#include <cryptopp/sha.h>
|
||||
|
||||
int main(int argc, char **argv){
|
||||
CryptoPP::SHA256 hash;
|
||||
std::string digest;
|
||||
std::string message = "Rosetta code";
|
||||
CryptoPP::SHA256 hash;
|
||||
std::string digest;
|
||||
std::string message = "Rosetta code";
|
||||
|
||||
CryptoPP::StringSource s(message, true,
|
||||
new CryptoPP::HashFilter(hash,
|
||||
new CryptoPP::HexEncoder(
|
||||
new CryptoPP::StringSink(digest))));
|
||||
CryptoPP::StringSource s(message, true,
|
||||
new CryptoPP::HashFilter(hash,
|
||||
new CryptoPP::HexEncoder(
|
||||
new CryptoPP::StringSink(digest))));
|
||||
|
||||
std::cout << digest << std::endl;
|
||||
std::cout << digest << std::endl;
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,84 +8,84 @@
|
|||
|
||||
class SHA256 {
|
||||
public:
|
||||
std::string message_digest(const std::string& message) {
|
||||
std::vector<int64_t> hash = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
|
||||
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
|
||||
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];
|
||||
}
|
||||
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];
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
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();
|
||||
}
|
||||
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));
|
||||
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));
|
||||
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;
|
||||
}
|
||||
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 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 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 );
|
||||
}
|
||||
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,
|
||||
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,
|
||||
|
|
@ -94,10 +94,10 @@ private:
|
|||
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
|
||||
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
|
||||
|
||||
const int32_t BLOCK_LENGTH = 64;
|
||||
const int32_t BLOCK_LENGTH = 64;
|
||||
};
|
||||
|
||||
int main() {
|
||||
SHA256 sha256;
|
||||
std::cout << sha256.message_digest("Rosetta code") << std::endl;
|
||||
SHA256 sha256;
|
||||
std::cout << sha256.message_digest("Rosetta code") << std::endl;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,13 +3,13 @@
|
|||
#include <openssl/sha.h>
|
||||
|
||||
int main (void) {
|
||||
const char *s = "Rosetta code";
|
||||
unsigned char *d = SHA256(s, strlen(s), 0);
|
||||
const char *s = "Rosetta code";
|
||||
unsigned char *d = SHA256(s, strlen(s), 0);
|
||||
|
||||
int i;
|
||||
for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
|
||||
printf("%02x", d[i]);
|
||||
putchar('\n');
|
||||
int i;
|
||||
for (i = 0; i < SHA256_DIGEST_LENGTH; i++)
|
||||
printf("%02x", d[i]);
|
||||
putchar('\n');
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ void local fn DoIt
|
|||
MutableStringAppendFormat( res, @"%02x", buf(i) )
|
||||
next
|
||||
NSLog(@"Input:\n%@\n",msg)
|
||||
NSLog(@"Output:\n%@", res)
|
||||
NSLog(@"Output:\n%@", res)
|
||||
end fn
|
||||
|
||||
fn DoIt
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
import haxe.crypto.Sha256;
|
||||
|
||||
class Main {
|
||||
static function main() {
|
||||
static function main() {
|
||||
var sha256 = Sha256.encode("Rosetta code");
|
||||
Sys.println(sha256);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,97 +3,97 @@ import java.util.Arrays;
|
|||
|
||||
public final class SHA256Task {
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println(SHA256.messageDigest("Rosetta code"));
|
||||
}
|
||||
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();
|
||||
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 ));
|
||||
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.ISO_8859_1);
|
||||
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 );
|
||||
}
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
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,
|
||||
private static byte[] addPadding(String message) {
|
||||
byte[] bytes = message.getBytes(StandardCharsets.ISO_8859_1);
|
||||
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;
|
||||
|
||||
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 };
|
||||
|
||||
private static final int BLOCK_LENGTH = 64;
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,130 +10,130 @@ my @h;
|
|||
my @k;
|
||||
|
||||
for my $p ( 2 .. 311 ) {
|
||||
# Horrible primality test, but sufficient for this task.
|
||||
next if ("1" x $p) =~ /^(11+?)\1+$/;
|
||||
# The choice to generate h and k instead of hard coding
|
||||
# them is inspired by the Raku implementation.
|
||||
my $c = $p ** ( 1/3 );
|
||||
push @k, int( ($c - int $c) * WORD );
|
||||
next if @h == 8;
|
||||
my $s = $p ** ( 1/2 );
|
||||
push @h, int( ($s - int $s) * WORD );
|
||||
# Horrible primality test, but sufficient for this task.
|
||||
next if ("1" x $p) =~ /^(11+?)\1+$/;
|
||||
# The choice to generate h and k instead of hard coding
|
||||
# them is inspired by the Raku implementation.
|
||||
my $c = $p ** ( 1/3 );
|
||||
push @k, int( ($c - int $c) * WORD );
|
||||
next if @h == 8;
|
||||
my $s = $p ** ( 1/2 );
|
||||
push @h, int( ($s - int $s) * WORD );
|
||||
}
|
||||
|
||||
sub new {
|
||||
my %self = ( state => [@h], str => "", len => 0 );
|
||||
bless \%self, shift;
|
||||
my %self = ( state => [@h], str => "", len => 0 );
|
||||
bless \%self, shift;
|
||||
}
|
||||
|
||||
my $rightrotate = sub {
|
||||
my $lo = $_[0] >> $_[1];
|
||||
my $hi = $_[0] << (32 - $_[1]);
|
||||
($hi | $lo);
|
||||
my $lo = $_[0] >> $_[1];
|
||||
my $hi = $_[0] << (32 - $_[1]);
|
||||
($hi | $lo);
|
||||
};
|
||||
|
||||
# This is adapted from the wikipedia entry on SHA2.
|
||||
my $compress = sub {
|
||||
my ($state, $bytes) = @_;
|
||||
my @w = unpack 'N*', $bytes;
|
||||
@w == 16 or die 'internal error';
|
||||
my ($a, $b, $c, $d, $e, $f, $g, $h) = @$state;
|
||||
until( @w == 64 ) {
|
||||
my $s0 = $w[-15] >> 3;
|
||||
my $s1 = $w[-2] >> 10;
|
||||
$s0 ^= $rightrotate->($w[-15], $_) for 7, 18;
|
||||
$s1 ^= $rightrotate->($w[-2], $_) for 17, 19;
|
||||
push @w, ($w[-16] + $s0 + $w[-7] + $s1) & MASK;
|
||||
}
|
||||
my $i = 0;
|
||||
for my $w (@w) {
|
||||
my $ch = ($e & $f) ^ ((~$e) & $g);
|
||||
my $maj = ($a & $b) ^ ($a & $c) ^ ($b & $c);
|
||||
my ($S0, $S1) = (0, 0);
|
||||
$S1 ^= $rightrotate->( $e, $_ ) for 6, 11, 25;
|
||||
$S0 ^= $rightrotate->( $a, $_ ) for 2, 13, 22;
|
||||
my $temp1 = $h + $S1 + $ch + $k[$i++] + $w;
|
||||
my $temp2 = $S0 + $maj;
|
||||
($h, $g, $f, $e, $d, $c, $b, $a) =
|
||||
($g, $f, $e, ($d+$temp1)&MASK, $c, $b, $a, ($temp1+$temp2)&MASK);
|
||||
}
|
||||
my $j = 0;
|
||||
$state->[$j++] += $_ for $a, $b, $c, $d, $e, $f, $g, $h;
|
||||
my ($state, $bytes) = @_;
|
||||
my @w = unpack 'N*', $bytes;
|
||||
@w == 16 or die 'internal error';
|
||||
my ($a, $b, $c, $d, $e, $f, $g, $h) = @$state;
|
||||
until( @w == 64 ) {
|
||||
my $s0 = $w[-15] >> 3;
|
||||
my $s1 = $w[-2] >> 10;
|
||||
$s0 ^= $rightrotate->($w[-15], $_) for 7, 18;
|
||||
$s1 ^= $rightrotate->($w[-2], $_) for 17, 19;
|
||||
push @w, ($w[-16] + $s0 + $w[-7] + $s1) & MASK;
|
||||
}
|
||||
my $i = 0;
|
||||
for my $w (@w) {
|
||||
my $ch = ($e & $f) ^ ((~$e) & $g);
|
||||
my $maj = ($a & $b) ^ ($a & $c) ^ ($b & $c);
|
||||
my ($S0, $S1) = (0, 0);
|
||||
$S1 ^= $rightrotate->( $e, $_ ) for 6, 11, 25;
|
||||
$S0 ^= $rightrotate->( $a, $_ ) for 2, 13, 22;
|
||||
my $temp1 = $h + $S1 + $ch + $k[$i++] + $w;
|
||||
my $temp2 = $S0 + $maj;
|
||||
($h, $g, $f, $e, $d, $c, $b, $a) =
|
||||
($g, $f, $e, ($d+$temp1)&MASK, $c, $b, $a, ($temp1+$temp2)&MASK);
|
||||
}
|
||||
my $j = 0;
|
||||
$state->[$j++] += $_ for $a, $b, $c, $d, $e, $f, $g, $h;
|
||||
};
|
||||
|
||||
use constant can_Q => eval { length pack 'Q>', 0 };
|
||||
|
||||
sub add {
|
||||
my ($self, $bytes) = @_;
|
||||
$self->{len} += 8 * length $bytes;
|
||||
if( !can_Q and $self->{len} >= WORD ) {
|
||||
my $hi = int( $self->{len} / WORD );
|
||||
$self->{big} += $hi;
|
||||
$self->{len} -= $hi * WORD;
|
||||
}
|
||||
my $len = length $self->{str};
|
||||
if( ($len + length $bytes) < 64 ) {
|
||||
$self->{str} .= $bytes;
|
||||
return $self;
|
||||
}
|
||||
my $off = 64 - $len;
|
||||
$compress->( $self->{state}, $self->{str} . substr( $bytes, 0, $off ) );
|
||||
$len = length $_[0];
|
||||
while( $off+64 <= $len ) {
|
||||
$compress->( $self->{state}, substr( $bytes, $off, 64 ) );
|
||||
$off += 64;
|
||||
}
|
||||
$self->{str} = substr( $bytes, $off );
|
||||
$self;
|
||||
my ($self, $bytes) = @_;
|
||||
$self->{len} += 8 * length $bytes;
|
||||
if( !can_Q and $self->{len} >= WORD ) {
|
||||
my $hi = int( $self->{len} / WORD );
|
||||
$self->{big} += $hi;
|
||||
$self->{len} -= $hi * WORD;
|
||||
}
|
||||
my $len = length $self->{str};
|
||||
if( ($len + length $bytes) < 64 ) {
|
||||
$self->{str} .= $bytes;
|
||||
return $self;
|
||||
}
|
||||
my $off = 64 - $len;
|
||||
$compress->( $self->{state}, $self->{str} . substr( $bytes, 0, $off ) );
|
||||
$len = length $_[0];
|
||||
while( $off+64 <= $len ) {
|
||||
$compress->( $self->{state}, substr( $bytes, $off, 64 ) );
|
||||
$off += 64;
|
||||
}
|
||||
$self->{str} = substr( $bytes, $off );
|
||||
$self;
|
||||
}
|
||||
|
||||
sub addfile {
|
||||
my ($self, $fh) = @_;
|
||||
my $s = "";
|
||||
while( read( $fh, $s, 2**13 ) ) {
|
||||
$self->add( $s );
|
||||
}
|
||||
$self;
|
||||
my ($self, $fh) = @_;
|
||||
my $s = "";
|
||||
while( read( $fh, $s, 2**13 ) ) {
|
||||
$self->add( $s );
|
||||
}
|
||||
$self;
|
||||
}
|
||||
|
||||
|
||||
sub digest {
|
||||
my $self = shift;
|
||||
my $final = $self->{str};
|
||||
$final .= chr 0x80;
|
||||
while( ( 8+length $final ) % 64 ) {
|
||||
$final .= chr 0;
|
||||
}
|
||||
if( can_Q ) {
|
||||
$final .= pack 'Q>', $self->{len};
|
||||
} else {
|
||||
$self->{big} ||= 0;
|
||||
$final .= pack 'NN', $self->{big}, $self->{len};
|
||||
}
|
||||
$compress->( $self->{state}, substr $final, 0, 64, "" ) while length $final;
|
||||
if( wantarray ) {
|
||||
map pack('N', $_), @{ $self->{state} };
|
||||
} else {
|
||||
pack 'N*', @{ $self->{state} };
|
||||
}
|
||||
my $self = shift;
|
||||
my $final = $self->{str};
|
||||
$final .= chr 0x80;
|
||||
while( ( 8+length $final ) % 64 ) {
|
||||
$final .= chr 0;
|
||||
}
|
||||
if( can_Q ) {
|
||||
$final .= pack 'Q>', $self->{len};
|
||||
} else {
|
||||
$self->{big} ||= 0;
|
||||
$final .= pack 'NN', $self->{big}, $self->{len};
|
||||
}
|
||||
$compress->( $self->{state}, substr $final, 0, 64, "" ) while length $final;
|
||||
if( wantarray ) {
|
||||
map pack('N', $_), @{ $self->{state} };
|
||||
} else {
|
||||
pack 'N*', @{ $self->{state} };
|
||||
}
|
||||
}
|
||||
|
||||
sub hexdigest {
|
||||
if( wantarray ) {
|
||||
map unpack( 'H*', $_), &digest;
|
||||
} else {
|
||||
unpack 'H*', &digest;
|
||||
}
|
||||
if( wantarray ) {
|
||||
map unpack( 'H*', $_), &digest;
|
||||
} else {
|
||||
unpack 'H*', &digest;
|
||||
}
|
||||
}
|
||||
|
||||
unless( caller ) {
|
||||
my @testwith = (@ARGV ? @ARGV : 'Rosetta code');
|
||||
for my $str (@testwith) {
|
||||
my $digester = __PACKAGE__->new;
|
||||
$digester->add($str);
|
||||
print "'$str':\n";
|
||||
print join(" ", $digester->hexdigest), "\n";
|
||||
}
|
||||
my @testwith = (@ARGV ? @ARGV : 'Rosetta code');
|
||||
for my $str (@testwith) {
|
||||
my $digester = __PACKAGE__->new;
|
||||
$digester->add($str);
|
||||
print "'$str':\n";
|
||||
print join(" ", $digester->hexdigest), "\n";
|
||||
}
|
||||
}
|
||||
|
||||
1;
|
||||
|
|
|
|||
1
Task/SHA-256/REBOL/sha-256.rebol
Normal file
1
Task/SHA-256/REBOL/sha-256.rebol
Normal file
|
|
@ -0,0 +1 @@
|
|||
checksum "Rosetta code" 'sha256
|
||||
|
|
@ -15,28 +15,28 @@ multi sha256(blob8 $data) {
|
|||
|
||||
return blob8.new:
|
||||
map |*.polymod(256 xx 3).reverse,
|
||||
|reduce -> $H, $block {
|
||||
blob32.new: $H[] Z+
|
||||
reduce -> $h, $j {
|
||||
my uint32 ($T1, $T2) =
|
||||
$h[7] + Σ1($h[4]) + Ch(|$h[4..6])
|
||||
+ (BEGIN init(* **(1/3))[^64])[$j] +
|
||||
(
|
||||
(state buf32 $w .= new)[$j] = $j < 16 ?? $block[$j] !!
|
||||
σ0($w[$j-15]) + $w[$j-7] + σ1($w[$j-2]) + $w[$j-16]
|
||||
),
|
||||
Σ0($h[0]) + Maj(|$h[0..2]);
|
||||
blob32.new: $T1 + $T2, |$h[0..2], $h[3] + $T1, |$h[4..6];
|
||||
}, $H, |^64;
|
||||
},
|
||||
(BEGIN init(&sqrt)[^8]),
|
||||
|blob32.new(
|
||||
blob8.new(
|
||||
@$data,
|
||||
0x80,
|
||||
0 xx (-($data + 1 + 8) mod 64),
|
||||
(8*$data).polymod(256 xx 7).reverse
|
||||
).rotor(4)
|
||||
.map: { :256[@$_] }
|
||||
).rotor(16)
|
||||
|reduce -> $H, $block {
|
||||
blob32.new: $H[] Z+
|
||||
reduce -> $h, $j {
|
||||
my uint32 ($T1, $T2) =
|
||||
$h[7] + Σ1($h[4]) + Ch(|$h[4..6])
|
||||
+ (BEGIN init(* **(1/3))[^64])[$j] +
|
||||
(
|
||||
(state buf32 $w .= new)[$j] = $j < 16 ?? $block[$j] !!
|
||||
σ0($w[$j-15]) + $w[$j-7] + σ1($w[$j-2]) + $w[$j-16]
|
||||
),
|
||||
Σ0($h[0]) + Maj(|$h[0..2]);
|
||||
blob32.new: $T1 + $T2, |$h[0..2], $h[3] + $T1, |$h[4..6];
|
||||
}, $H, |^64;
|
||||
},
|
||||
(BEGIN init(&sqrt)[^8]),
|
||||
|blob32.new(
|
||||
blob8.new(
|
||||
@$data,
|
||||
0x80,
|
||||
0 xx (-($data + 1 + 8) mod 64),
|
||||
(8*$data).polymod(256 xx 7).reverse
|
||||
).rotor(4)
|
||||
.map: { :256[@$_] }
|
||||
).rotor(16)
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue