【加班不再有】SHA2

admin 2022年11月30日00:01:10安全闲碎评论6 views36694字阅读122分18秒阅读模式

【加班不再有】SHA2

【加班不再有】SHA2

📌这里给出常见语言的「SHA2」调用方案,目前已按照语言的「字母序」(正序)进行排列,方便读者查找。

Bash

#!/bin/bash

echo -n "" | openssl dgst -sha224
echo -n "" | openssl dgst -sha256
echo -n "" | openssl dgst -sha384
echo -n "" | openssl dgst -sha512
echo -n "" | openssl dgst -sha512-224
echo -n "" | openssl dgst -sha512-256

C

这里有点问题,因为原始的boringssl是没有实现sha512_224的,因此这里需要直接改下源码,实现下这个算法,这里简单的改改吧,目测我这里改的是对的。

依赖库

  • boringssl

需要新增的代码

// include/openssl/sha.h
// SHA-512-224

#define SHA512_224_DIGEST_LENGTH 28

// SHA512_224_Init initialises |sha| and returns 1.
OPENSSL_EXPORT int SHA512_224_Init(SHA512_CTX *sha);

// SHA512_224_Update adds |len| bytes from |data| to |sha| and returns 1.
OPENSSL_EXPORT int SHA512_224_Update(SHA512_CTX *sha, const void *data,
                                     size_t len)
;

// SHA512_224_Final adds the final padding to |sha| and writes the resulting
// digest to |out|, which must have at least |SHA512_224_DIGEST_LENGTH| bytes of
// space. It returns one on success and zero on programmer error.
OPENSSL_EXPORT int SHA512_224_Final(uint8_t out[SHA512_224_DIGEST_LENGTH],
                                    SHA512_CTX *sha)
;

// SHA512_224 writes the digest of |len| bytes from |data| to |out| and returns
// |out|. There must be at least |SHA512_256_DIGEST_LENGTH| bytes of space in
// |out|.
OPENSSL_EXPORT uint8_t *SHA512_224(const uint8_t *data, size_t len,
                                   uint8_t out[SHA512_224_DIGEST_LENGTH])
;

// crypto/fipsmodule/sha/sha512.c
int SHA512_224_Init(SHA512_CTX *sha) {
  sha->h[0] = UINT64_C(0x8C3D37C819544DA2);
  sha->h[1] = UINT64_C(0x73E1996689DCD4D6);
  sha->h[2] = UINT64_C(0x1DFAB7AE32FF9C82);
  sha->h[3] = UINT64_C(0x679DD514582F9FCF);
  sha->h[4] = UINT64_C(0x0F6D2B697BD44DA8);
  sha->h[5] = UINT64_C(0x77E36F7304C48942);
  sha->h[6] = UINT64_C(0x3F9D85A86A1D36C8);
  sha->h[7] = UINT64_C(0x1112E6AD91D692A1);

  sha->Nl = 0;
  sha->Nh = 0;
  sha->num = 0;
  sha->md_len = SHA512_224_DIGEST_LENGTH;
  return 1;
}

uint8_t *SHA512_224(const uint8_t *data, size_t len,
                    uint8_t out[SHA512_224_DIGEST_LENGTH])
 
{
  SHA512_CTX ctx;
  SHA512_224_Init(&ctx);
  SHA512_224_Update(&ctx, data, len);
  SHA512_224_Final(out, &ctx);
  OPENSSL_cleanse(&ctx, sizeof(ctx));
  return out;
}

int SHA512_224_Update(SHA512_CTX *sha, const void *data, size_t len) {
  return SHA512_Update(sha, data, len);
}

int SHA512_224_Final(uint8_t out[SHA512_224_DIGEST_LENGTH], SHA512_CTX *sha) {
  // This function must be paired with |SHA512_224_Init|, which sets
  // |sha->md_len| to |SHA512_224_DIGEST_LENGTH|.
  assert(sha->md_len == SHA512_224_DIGEST_LENGTH);
  return sha512_final_impl(out, SHA512_224_DIGEST_LENGTH, sha);
}

static int sha512_final_impl(uint8_t *out, size_t md_len, SHA512_CTX *sha) {
   // ...

  // assert(md_len % 8 == 0);
  size_t out_words = md_len / 8;
  if (md_len == 28) {
    out_words = 4;
  }
  // ...
}

代码

#include <cstdio>
#include <cstring>
#include "openssl/sha.h"


static void sha224(const char *message, char *output) {
  unsigned char digest[SHA224_DIGEST_LENGTH];
  SHA256_CTX ctx;
  SHA224_Init(&ctx);
  SHA224_Update(&ctx, message, strlen(message));
  SHA224_Final(digest, &ctx);
  for (int i = 0; i < SHA224_DIGEST_LENGTH; i++) {
    sprintf(output + (i * 2), "%02x", (unsigned int)digest[i]);
  }
}

static void sha256(const char *message, char *output) {
  unsigned char digest[SHA256_DIGEST_LENGTH];
  SHA256_CTX ctx;
  SHA256_Init(&ctx);
  SHA256_Update(&ctx, message, strlen(message));
  SHA256_Final(digest, &ctx);
  for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
    sprintf(output + (i * 2), "%02x", (unsigned int)digest[i]);
  }
}

static void sha384(const char *message, char *output) {
  unsigned char digest[SHA384_DIGEST_LENGTH];
  SHA512_CTX ctx;
  SHA384_Init(&ctx);
  SHA384_Update(&ctx, message, strlen(message));
  SHA384_Final(digest, &ctx);
  for (int i = 0; i < SHA384_DIGEST_LENGTH; i++) {
    sprintf(output + (i * 2), "%02x", (unsigned int)digest[i]);
  }
}

static void sha512(const char *message, char *output) {
  unsigned char digest[SHA512_DIGEST_LENGTH];
  SHA512_CTX ctx;
  SHA512_Init(&ctx);
  SHA512_Update(&ctx, message, strlen(message));
  SHA512_Final(digest, &ctx);
  for (int i = 0; i < SHA512_DIGEST_LENGTH; i++) {
    sprintf(output + (i * 2), "%02x", (unsigned int)digest[i]);
  }
}

static void sha512_224(const char *message, char *output) {
  unsigned char digest[SHA512_224_DIGEST_LENGTH];
  SHA512_CTX ctx;
  SHA512_224_Init(&ctx);
  SHA512_224_Update(&ctx, message, strlen(message));
  SHA512_224_Final(digest, &ctx);
  for (int i = 0; i < SHA512_224_DIGEST_LENGTH; i++) {
    sprintf(output + (i * 2), "%02x", (unsigned int)digest[i]);
  }
}

static void sha512_256(const char *message, char *output) {
  unsigned char digest[SHA256_DIGEST_LENGTH];
  SHA512_CTX ctx;
  SHA512_256_Init(&ctx);
  SHA512_256_Update(&ctx, message, strlen(message));
  SHA512_256_Final(digest, &ctx);
  for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
    sprintf(output + (i * 2), "%02x", (unsigned int)digest[i]);
  }
}

使用样例


int main(int argc, char **argv) {
  char sha224_output[SHA224_DIGEST_LENGTH];
  sha224("", sha224_output);
  printf("%sn", sha224_output);
  sha224("Hello, world!", sha224_output);
  printf("%sn", sha224_output);
  sha224("The quick brown fox jumps over the lazy dog.", sha224_output);
  printf("%sn", sha224_output);

  char sha256_output[SHA256_DIGEST_LENGTH];
  sha256("", sha256_output);
  printf("%sn", sha256_output);
  sha256("Hello, world!", sha256_output);
  printf("%sn", sha256_output);
  sha256("The quick brown fox jumps over the lazy dog.", sha256_output);
  printf("%sn", sha256_output);

  char sha384_output[SHA384_DIGEST_LENGTH];
  sha384("", sha384_output);
  printf("%sn", sha384_output);
  sha384("Hello, world!", sha384_output);
  printf("%sn", sha384_output);
  sha384("The quick brown fox jumps over the lazy dog.", sha384_output);
  printf("%sn", sha384_output);

  char sha512_output[SHA512_DIGEST_LENGTH];
  sha512("", sha512_output);
  printf("%sn", sha512_output);
  sha512("Hello, world!", sha512_output);
  printf("%sn", sha512_output);
  sha512("The quick brown fox jumps over the lazy dog.", sha512_output);
  printf("%sn", sha512_output);

  sha512_224("", sha224_output);
  printf("%sn", sha224_output);
  sha512_224("Hello, world!", sha224_output);
  printf("%sn", sha224_output);
  sha512_224("The quick brown fox jumps over the lazy dog.", sha224_output);
  printf("%sn", sha224_output);

  sha512_256("", sha256_output);
  printf("%sn", sha256_output);
  sha512_256("Hello, world!", sha256_output);
  printf("%sn", sha256_output);
  sha512_256("The quick brown fox jumps over the lazy dog.", sha256_output);
  printf("%sn", sha256_output);
  return 0;
}

C++

依赖库

  • botan

这俩库是不是商量好了,都不给sha512/224的实现,这里还是需要自己补一下,咱们简单的小补一下就完事了。

补充代码

// src/lib/hash/hash.cpp

#if defined(BOTAN_HAS_SHA2_64)
   // ...

   if(algo_spec == "SHA-512-224")
      {
      return std::make_unique<SHA_512_224>();
      }

   // ...
#endif

// src/lib/hash/sha2_64/sha2_64.cpp


std::unique_ptr<HashFunction> SHA_512_224::copy_state() const
    
{
        return std::make_unique<SHA_512_224>(*this);
    }
    
std::string SHA_512_224::provider() const
    
{
        return sha512_provider();
    }    

void SHA_512_224::compress_n(const uint8_t input[], size_t blocks)
    
{
        SHA_512::compress_digest(m_digest, input, blocks);
    }

void SHA_512_224::copy_out(uint8_t output[])
    
{
        copy_out_vec_be(output, output_length(), m_digest);
    }
    
void SHA_512_224::clear()
    
{
        MDx_HashFunction::clear();
        m_digest[0] = 0x8C3D37C819544DA2;
        m_digest[1] = 0x73E1996689DCD4D6;
        m_digest[2] = 0x1DFAB7AE32FF9C82;
        m_digest[3] = 0x679DD514582F9FCF;
        m_digest[4] = 0x0F6D2B697BD44DA8;
        m_digest[5] = 0x77E36F7304C48942;
        m_digest[6] = 0x3F9D85A86A1D36C8;
        m_digest[7] = 0x1112E6AD91D692A1;
    }        

代码

#include <iostream>
#include "../lib/hash/hash.h"
#include "../lib/base/symkey.h"

std::string sha224(const std::string &message) {
    auto hash = Botan::HashFunction::create("SHA-224");
    auto result = hash->process(message);
    return Botan::OctetString(result).to_string();
}

std::string sha256(const std::string &message) {
    auto hash = Botan::HashFunction::create("SHA-256");
    auto result = hash->process(message);
    return Botan::OctetString(result).to_string();
}

std::string sha384(const std::string &message) {
    auto hash = Botan::HashFunction::create("SHA-384");
    auto result = hash->process(message);
    return Botan::OctetString(result).to_string();
}

std::string sha512(const std::string &message) {
    auto hash = Botan::HashFunction::create("SHA-512");
    auto result = hash->process(message);
    return Botan::OctetString(result).to_string();
}

std::string sha512_224(const std::string &message) {
    auto hash = Botan::HashFunction::create("SHA-512-224");
    auto result = hash->process(message);
    return Botan::OctetString(result).to_string();
}

std::string sha512_256(const std::string &message) {
    auto hash = Botan::HashFunction::create("SHA-512-256");
    auto result = hash->process(message);
    return Botan::OctetString(result).to_string();
}

使用样例

int main(int argc, char *argv[]) {
    std::cout << sha224("") << std::endl;
    std::cout << sha224("Hello, world!") << std::endl;
    std::cout << sha224("The quick brown fox jumps over the lazy dog.") << std::endl;

    std::cout << sha256("") << std::endl;
    std::cout << sha256("Hello, world!") << std::endl;
    std::cout << sha256("The quick brown fox jumps over the lazy dog.") << std::endl;

    std::cout << sha384("") << std::endl;
    std::cout << sha384("Hello, world!") << std::endl;
    std::cout << sha384("The quick brown fox jumps over the lazy dog.") << std::endl;

    std::cout << sha512("") << std::endl;
    std::cout << sha512("Hello, world!") << std::endl;
    std::cout << sha512("The quick brown fox jumps over the lazy dog.") << std::endl;

    std::cout << sha512_224("") << std::endl;
    std::cout << sha512_224("Hello, world!") << std::endl;
    std::cout << sha512_224("The quick brown fox jumps over the lazy dog.") << std::endl;

    std::cout << sha512_256("") << std::endl;
    std::cout << sha512_256("Hello, world!") << std::endl;
    std::cout << sha512_256("The quick brown fox jumps over the lazy dog.") << std::endl;
    return 0;
}

C#

📌目前C#暂未找到合适的sha224sha512_224sha512_256的调用,自带的函数不带这些,如果读者有好的库可以使用,欢迎和我交流,提示,需保证是正确的实现,并且最好是官方推荐或者使用人数较多的库,用以确保使用的安全性。

代码

using System.Security.Cryptography;
using System.Text;

string Sha256(string message)
{
    StringBuilder stringBuilder = new StringBuilder();
    using (SHA256 hasher = SHA256.Create())
    {
        byte[] bytes = hasher.ComputeHash(Encoding.UTF8.GetBytes(message));
        foreach (byte b in bytes)
        {
            stringBuilder.Append(b.ToString("x2"));
        }
    }
    return stringBuilder.ToString();
}

string Sha384(string message)
{
    StringBuilder stringBuilder = new StringBuilder();
    using (SHA384 hasher = SHA384.Create())
    {
        byte[] bytes = hasher.ComputeHash(Encoding.UTF8.GetBytes(message));
        foreach (byte b in bytes)
        {
            stringBuilder.Append(b.ToString("x2"));
        }
    }
    return stringBuilder.ToString();
}

string Sha512(string message)
{
    StringBuilder stringBuilder = new StringBuilder();
    using (SHA512 hasher = SHA512.Create())
    {
        byte[] bytes = hasher.ComputeHash(Encoding.UTF8.GetBytes(message));
        foreach (byte b in bytes)
        {
            stringBuilder.Append(b.ToString("x2"));
        }
    }
    return stringBuilder.ToString();
}

使用样例

Console.WriteLine(Sha256(""));
Console.WriteLine(Sha256("Hello, World!"));
Console.WriteLine(Sha256("The quick brown fox jumps over the lazy dog."));

Console.WriteLine(Sha384(""));
Console.WriteLine(Sha384("Hello, World!"));
Console.WriteLine(Sha384("The quick brown fox jumps over the lazy dog."));

Console.WriteLine(Sha512(""));
Console.WriteLine(Sha512("Hello, World!"));
Console.WriteLine(Sha512("The quick brown fox jumps over the lazy dog."));

Dart

依赖

dependencies:
  # ...
  crypto: 3.0.2
  # ...

代码

import 'dart:convert';

import 'package:crypto/crypto.dart';

String sha224ToHex(String message) {
  return sha224.convert(utf8.encode(message)).toString();
}

String sha256ToHex(String message) {
  return sha256.convert(utf8.encode(message)).toString();
}

String sha384ToHex(String message) {
  return sha384.convert(utf8.encode(message)).toString();
}

String sha512ToHex(String message) {
  return sha512.convert(utf8.encode(message)).toString();
}

String sha512_224ToHex(String message) {
  return sha512224.convert(utf8.encode(message)).toString();
}

String sha512_256ToHex(String message) {
  return sha512256.convert(utf8.encode(message)).toString();
}

使用样例

void main(List<String> arguments) {
  print(sha224ToHex(""));
  print(sha224ToHex("Hello, world!"));
  print(sha224ToHex("The quick brown fox jumps over the lazy dog."));

  print(sha256ToHex(""));
  print(sha256ToHex("Hello, world!"));
  print(sha256ToHex("The quick brown fox jumps over the lazy dog."));

  print(sha384ToHex(""));
  print(sha384ToHex("Hello, world!"));
  print(sha384ToHex("The quick brown fox jumps over the lazy dog."));

  print(sha512ToHex(""));
  print(sha512ToHex("Hello, world!"));
  print(sha512ToHex("The quick brown fox jumps over the lazy dog."));

  print(sha512_224ToHex(""));
  print(sha512_224ToHex("Hello, world!"));
  print(sha512_224ToHex("The quick brown fox jumps over the lazy dog."));

  print(sha512_256ToHex(""));
  print(sha512_256ToHex("Hello, world!"));
  print(sha512_256ToHex("The quick brown fox jumps over the lazy dog."));
}

Go

代码

package main

import (
  "crypto/sha256"
  "crypto/sha512"
  "encoding/hex"
)

func SHA224(message string) string {
  hash := sha256.Sum224([]byte(message))
  return hex.EncodeToString(hash[:])
}

func SHA256(message string) string {
  hash := sha256.Sum256([]byte(message))
  return hex.EncodeToString(hash[:])
}

func SHA384(message string) string {
  hash := sha512.Sum384([]byte(message))
  return hex.EncodeToString(hash[:])
}

func SHA512(message string) string {
  hash := sha512.Sum512([]byte(message))
  return hex.EncodeToString(hash[:])
}

//goland:noinspection ALL
func SHA512_224(message string) string {
  hash := sha512.Sum512_224([]byte(message))
  return hex.EncodeToString(hash[:])
}

func SHA512_256(message string) string {
  hash := sha512.Sum512_256([]byte(message))
  return hex.EncodeToString(hash[:])
}

使用样例

func main() {
  println(SHA224(""))
  println(SHA224("Hello World!"))
  println(SHA224("The quick brown fox jumps over the lazy dog."))

  println(SHA256(""))
  println(SHA256("Hello World!"))
  println(SHA256("The quick brown fox jumps over the lazy dog."))

  println(SHA384(""))
  println(SHA384("Hello World!"))
  println(SHA384("The quick brown fox jumps over the lazy dog."))

  println(SHA512(""))
  println(SHA512("Hello World!"))
  println(SHA512("The quick brown fox jumps over the lazy dog."))

  println(SHA512_224(""))
  println(SHA512_224("Hello World!"))
  println(SHA512_224("The quick brown fox jumps over the lazy dog."))

  println(SHA512_256(""))
  println(SHA512_256("Hello World!"))
  println(SHA512_256("The quick brown fox jumps over the lazy dog."))
}

Java

代码

package com.littleq;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Main {

    public static String byteArrayToHex(byte[] a) {
        StringBuilder sb = new StringBuilder(a.length * 2);
        for (byte b : a)
            sb.append(String.format("%02x", b));
        return sb.toString();
    }

    static String sha224(String message) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-224");
        return byteArrayToHex(md.digest(message.getBytes()));
    }

    static String sha256(String message) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        return byteArrayToHex(md.digest(message.getBytes()));
    }

    static String sha384(String message) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-384");
        return byteArrayToHex(md.digest(message.getBytes()));
    }

    static String sha512(String message) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-512");
        return byteArrayToHex(md.digest(message.getBytes()));
    }

    static String sha512_224(String message) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-512/224");
        return byteArrayToHex(md.digest(message.getBytes()));
    }

    static String sha512_256(String message) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-512/256");
        return byteArrayToHex(md.digest(message.getBytes()));
    }
}

使用样例

package com.littleq;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class Main {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        System.out.println(sha224(""));
        System.out.println(sha224("Hello, world!"));
        System.out.println(sha224("The quick brown fox jumps over the lazy dog."));

        System.out.println(sha256(""));
        System.out.println(sha256("Hello, world!"));
        System.out.println(sha256("The quick brown fox jumps over the lazy dog."));

        System.out.println(sha384(""));
        System.out.println(sha384("Hello, world!"));
        System.out.println(sha384("The quick brown fox jumps over the lazy dog."));

        System.out.println(sha512(""));
        System.out.println(sha512("Hello, world!"));
        System.out.println(sha512("The quick brown fox jumps over the lazy dog."));

        System.out.println(sha512_224(""));
        System.out.println(sha512_224("Hello, world!"));
        System.out.println(sha512_224("The quick brown fox jumps over the lazy dog."));

        System.out.println(sha512_256(""));
        System.out.println(sha512_256("Hello, world!"));
        System.out.println(sha512_256("The quick brown fox jumps over the lazy dog."));
    }
}

JavaScript

代码

const crypto = require('crypto');


function sha224(message{
    return crypto.createHash('sha224').update(message).digest('hex');
}

function sha256(message{
    return crypto.createHash('sha256').update(message).digest('hex');
}

function sha384(message{
    return crypto.createHash('sha384').update(message).digest('hex');
}

function sha512(message{
    return crypto.createHash('sha512').update(message).digest('hex');
}

function sha512_224(message{
    return crypto.createHash('sha512-224').update(message).digest('hex');
}

function sha512_256(message{
    return crypto.createHash('sha512-256').update(message).digest('hex');
}


使用样例

function main({
    console.log(sha224(''));
    console.log(sha224('Hello, World!'));
    console.log(sha224('The quick brown fox jumps over the lazy dog.'));

    console.log(sha256(''));
    console.log(sha256('Hello, World!'));
    console.log(sha256('The quick brown fox jumps over the lazy dog.'));

    console.log(sha384(''));
    console.log(sha384('Hello, World!'));
    console.log(sha384('The quick brown fox jumps over the lazy dog.'));

    console.log(sha512(''));
    console.log(sha512('Hello, World!'));
    console.log(sha512('The quick brown fox jumps over the lazy dog.'));

    console.log(sha512_224(''));
    console.log(sha512_224('Hello, World!'));
    console.log(sha512_224('The quick brown fox jumps over the lazy dog.'));

    console.log(sha512_256(''));
    console.log(sha512_256('Hello, World!'));
    console.log(sha512_256('The quick brown fox jumps over the lazy dog.'));
}

main();

Kotlin

代码

import java.security.MessageDigest

fun sha224(message: String): String {
    val md = MessageDigest.getInstance("SHA-224")
    val digest = md.digest(message.toByteArray())
    return digest.fold("") { str, it -> str + "%02x".format(it) }
}

fun sha256(message: String): String {
    val md = MessageDigest.getInstance("SHA-256")
    val digest = md.digest(message.toByteArray())
    return digest.fold("") { str, it -> str + "%02x".format(it) }
}

fun sha384(message: String): String {
    val md = MessageDigest.getInstance("SHA-384")
    val digest = md.digest(message.toByteArray())
    return digest.fold("") { str, it -> str + "%02x".format(it) }
}

fun sha512(message: String): String {
    val md = MessageDigest.getInstance("SHA-512")
    val digest = md.digest(message.toByteArray())
    return digest.fold("") { str, it -> str + "%02x".format(it) }
}

@Suppress("FunctionName")
fun sha512_224(message: String): String {
    val md = MessageDigest.getInstance("SHA-512/224")
    val digest = md.digest(message.toByteArray())
    return digest.fold("") { str, it -> str + "%02x".format(it) }
}

@Suppress("FunctionName")
fun sha512_256(message: String): String {
    val md = MessageDigest.getInstance("SHA-512/256")
    val digest = md.digest(message.toByteArray())
    return digest.fold("") { str, it -> str + "%02x".format(it) }
}


使用样例

fun main(args: Array<String>) {
    println(sha224(""))
    println(sha224("Hello, world!"))
    println(sha224("The quick brown fox jumps over the lazy dog."))

    println(sha256(""))
    println(sha256("Hello, world!"))
    println(sha256("The quick brown fox jumps over the lazy dog."))

    println(sha384(""))
    println(sha384("Hello, world!"))
    println(sha384("The quick brown fox jumps over the lazy dog."))

    println(sha512(""))
    println(sha512("Hello, world!"))
    println(sha512("The quick brown fox jumps over the lazy dog."))

    println(sha512_224(""))
    println(sha512_224("Hello, world!"))
    println(sha512_224("The quick brown fox jumps over the lazy dog."))

    println(sha512_256(""))
    println(sha512_256("Hello, world!"))
    println(sha512_256("The quick brown fox jumps over the lazy dog."))
}

Objective-C

目前未找到Objective-C对于sha512_224以及sha512_256的的调用,自带的函数不带这些,如果读者有好的库可以使用,欢迎和我交流,提示,需保证是正确的实现,并且最好是官方推荐或者使用人数较多的库,用以确保使用的安全性。

代码

#import <CommonCrypto/CommonDigest.h>

NSString *sha224(NSString *message) {
unsigned char result[CC_SHA224_DIGEST_LENGTH];
CC_SHA224([message UTF8String], (CC_LONG) [message lengthOfBytesUsingEncoding:NSUTF8StringEncoding], result);
NSMutableString *hash = [NSMutableString string];
for (int i = 0; i < CC_SHA224_DIGEST_LENGTH; i++) {
[hash appendFormat:@"%02X", result[i]];
}
return [hash lowercaseString];
}

NSString *sha256(NSString *message) {
unsigned char result[CC_SHA256_DIGEST_LENGTH];
CC_SHA256([message UTF8String], (CC_LONG) [message lengthOfBytesUsingEncoding:NSUTF8StringEncoding], result);
NSMutableString *hash = [NSMutableString string];
for (int i = 0; i < CC_SHA256_DIGEST_LENGTH; i++) {
[hash appendFormat:@"%02X", result[i]];
}
return [hash lowercaseString];
}

NSString *sha384(NSString *message) {
unsigned char result[CC_SHA384_DIGEST_LENGTH];
CC_SHA384([message UTF8String], (CC_LONG) [message lengthOfBytesUsingEncoding:NSUTF8StringEncoding], result);
NSMutableString *hash = [NSMutableString string];
for (int i = 0; i < CC_SHA384_DIGEST_LENGTH; i++) {
[hash appendFormat:@"%02X", result[i]];
}
return [hash lowercaseString];
}

NSString *sha512(NSString *message) {
unsigned char result[CC_SHA512_DIGEST_LENGTH];
CC_SHA512([message UTF8String], (CC_LONG) [message lengthOfBytesUsingEncoding:NSUTF8StringEncoding], result);
NSMutableString *hash = [NSMutableString string];
for (int i = 0; i < CC_SHA512_DIGEST_LENGTH; i++) {
[hash appendFormat:@"%02X", result[i]];
}
return [hash lowercaseString];
}

使用样例

- (void)testExample {
NSLog(@"%s", sha224(@"").UTF8String);
NSLog(@"%s", sha224(@"Hello, world!").UTF8String);
NSLog(@"%s", sha224(@"The quick brown fox jumps over the lazy dog.").UTF8String);

NSLog(@"%s", sha256(@"").UTF8String);
NSLog(@"%s", sha256(@"Hello, world!").UTF8String);
NSLog(@"%s", sha256(@"The quick brown fox jumps over the lazy dog.").UTF8String);

NSLog(@"%s", sha384(@"").UTF8String);
NSLog(@"%s", sha384(@"Hello, world!").UTF8String);
NSLog(@"%s", sha384(@"The quick brown fox jumps over the lazy dog.").UTF8String);

NSLog(@"%s", sha512(@"").UTF8String);
NSLog(@"%s", sha512(@"Hello, world!").UTF8String);
NSLog(@"%s", sha512(@"The quick brown fox jumps over the lazy dog.").UTF8String);
}

PHP

代码

<?php

function sha224($message)string
{
    return hash('sha224', $message);
}

function sha256($message)string
{
    return hash('sha256', $message);
}

function sha384($message)string
{
    return hash('sha384', $message);
}

function sha512($message)string
{
    return hash('sha512', $message);
}

function sha512_224($message)string
{
    return hash('sha512/224', $message);
}

function sha512_256($message)string
{
    return hash('sha512/256', $message);
}


使用样例

<?php

echo sha224(''), PHP_EOL;
echo sha224('Hello, world!'), PHP_EOL;
echo sha224("The quick brown fox jumps over the lazy dog."), PHP_EOL;

echo sha256(""), PHP_EOL;
echo sha256("Hello, world!"), PHP_EOL;
echo sha256("The quick brown fox jumps over the lazy dog."), PHP_EOL;

echo sha384(""), PHP_EOL;
echo sha384("Hello, world!"), PHP_EOL;
echo sha384("The quick brown fox jumps over the lazy dog."), PHP_EOL;

echo sha512(""), PHP_EOL;
echo sha512("Hello, world!"), PHP_EOL;
echo sha512("The quick brown fox jumps over the lazy dog."), PHP_EOL;

echo sha512_224(""), PHP_EOL;
echo sha512_224("Hello, world!"), PHP_EOL;
echo sha512_224("The quick brown fox jumps over the lazy dog."), PHP_EOL;

echo sha512_256(""), PHP_EOL;
echo sha512_256("Hello, world!"), PHP_EOL;
echo sha512_256("The quick brown fox jumps over the lazy dog."), PHP_EOL;

Python

因为原始Python不带有sha512_224以及sha512_256的相关实现,因此这里后两者采用如下依赖库实现

依赖库

  • pycryptodome==3.15.0

代码

import hashlib
from Crypto.Hash import SHA512


def sha224(message: str) -> str:
    return hashlib.sha224(message.encode()).hexdigest()


def sha256(message: str) -> str:
    return hashlib.sha256(message.encode()).hexdigest()


def sha384(message: str) -> str:
    return hashlib.sha384(message.encode()).hexdigest()


def sha512(message: str) -> str:
    return hashlib.sha512(message.encode()).hexdigest()


def sha512_224(message: str) -> str:
    hasher = SHA512.new(truncate="224")
    hasher.update(message.encode())
    return hasher.hexdigest()


def sha512_256(message: str) -> str:
    hasher = SHA512.new(truncate="256")
    hasher.update(message.encode())
    return hasher.hexdigest()

使用案例

if __name__ == '__main__':
    print(sha224(''))
    print(sha224('hello world'))
    print(sha224('The quick brown fox jumps over the lazy dog'))

    print(sha256(''))
    print(sha256('hello world!'))
    print(sha256('The quick brown fox jumps over the lazy dog.'))

    print(sha384(''))
    print(sha384('hello world!'))
    print(sha384('The quick brown fox jumps over the lazy dog.'))

    print(sha512(''))
    print(sha512('hello world!'))
    print(sha512('The quick brown fox jumps over the lazy dog.'))

    print(sha512_224(''))
    print(sha512_224('hello world!'))
    print(sha512_224('The quick brown fox jumps over the lazy dog.'))

    print(sha512_256(''))
    print(sha512_256('hello world!'))
    print(sha512_256('The quick brown fox jumps over the lazy dog.'))


R

📌目前R暂未找到合适的sha224sha384sha512_224sha512_256的调用,自带的函数不带这些,如果读者有好的库可以使用,欢迎和我交流,提示,需保证是正确的实现,并且最好是官方推荐或者使用人数较多的库,用以确保使用的安全性。

依赖库

  • digest 0.6.30

代码

library(digest)

sha256 <- function(message) {
  return(digest(message, algo = "sha256", serialize = FALSE))
}

sha512 <- function(message) {
  return(digest(message, algo = "sha512", serialize = FALSE))
}

使用案例

print(sha256(""))
print(sha256("Hello, world!"))
print(sha256("The quick brown fox jumps over the lazy dog."))

print(sha512(""))
print(sha512("Hello, world!"))
print(sha512("The quick brown fox jumps over the lazy dog."))

Ruby

📌目前Ruby暂未找到合适的sha224sha512_224sha512_256的调用,自带的函数不带这些,如果读者有好的库可以使用,欢迎和我交流,提示,需保证是正确的实现,并且最好是官方推荐或者使用人数较多的库,用以确保使用的安全性。

代码

require "test_helper"
require 'digest'

class Cryptography::DemoTest < Minitest::Test

  def sha256(message)
    Digest::SHA2.new(256).hexdigest(message)
  end

  def sha384(message)
    Digest::SHA2.new(384).hexdigest(message)
  end

  def sha512(message)
    Digest::SHA2.new(512).hexdigest(message)
  end
end

使用样例

require "test_helper"

class Cryptography::DemoTest < Minitest::Test
  def test_it_does_something_useful
    print(sha256("") + "n")
    print(sha256("Hello, world!") + "n")
    print(sha256("The quick brown fox jumps over the lazy dog.") + "n")

    print(sha384("") + "n")
    print(sha384("Hello, world!") + "n")
    print(sha384("The quick brown fox jumps over the lazy dog.") + "n")

    print(sha512("") + "n")
    print(sha512("Hello, world!") + "n")
    print(sha512("The quick brown fox jumps over the lazy dog.") + "n")
  end
end


Rust

依赖库

[dependencies]
sha2 = "0.10.6"

代码

use sha2::{Sha224, Sha256, Sha384, Sha512, Sha512_224, Sha512_256, Digest};

fn sha224(message: String) -> String {
    let mut hasher = Sha224::new();
    hasher.update(message.as_bytes());
    let result = hasher.finalize();
    return format!("{:x}", result);
}

fn sha256(message: String) -> String {
    let mut hasher = Sha256::new();
    hasher.update(message.as_bytes());
    let result = hasher.finalize();
    return format!("{:x}", result);
}

fn sha384(message: String) -> String {
    let mut hasher = Sha384::new();
    hasher.update(message.as_bytes());
    let result = hasher.finalize();
    return format!("{:x}", result);
}

fn sha512(message: String) -> String {
    let mut hasher = Sha512::new();
    hasher.update(message.as_bytes());
    let result = hasher.finalize();
    return format!("{:x}", result);
}

fn sha512_224(message: String) -> String {
    let mut hasher = Sha512_224::new();
    hasher.update(message.as_bytes());
    let result = hasher.finalize();
    return format!("{:x}", result);
}

fn sha512_256(message: String) -> String {
    let mut hasher = Sha512_256::new();
    hasher.update(message.as_bytes());
    let result = hasher.finalize();
    return format!("{:x}", result);
}

使用案例

fn main() {
    println!("{}", sha224("".to_string()));
    println!("{}", sha224("Hello, world!".to_string()));
    println!("{}", sha224("The quick brown fox jumps over the lazy dog.".to_string()));

    println!("{}", sha256("".to_string()));
    println!("{}", sha256("Hello, world!".to_string()));
    println!("{}", sha256("The quick brown fox jumps over the lazy dog.".to_string()));

    println!("{}", sha384("".to_string()));
    println!("{}", sha384("Hello, world!".to_string()));
    println!("{}", sha384("The quick brown fox jumps over the lazy dog.".to_string()));

    println!("{}", sha512("".to_string()));
    println!("{}", sha512("Hello, world!".to_string()));
    println!("{}", sha512("The quick brown fox jumps over the lazy dog.".to_string()));

    println!("{}", sha512_224("".to_string()));
    println!("{}", sha512_224("Hello, world!".to_string()));
    println!("{}", sha512_224("The quick brown fox jumps over the lazy dog.".to_string()));

    println!("{}", sha512_256("".to_string()));
    println!("{}", sha512_256("Hello, world!".to_string()));
    println!("{}", sha512_256("The quick brown fox jumps over the lazy dog.".to_string()));
}

Swift

📌目前未找到Swift对于sha512_224以及sha512_256的的调用,自带的函数不带这些,如果读者有好的库可以使用,欢迎和我交流,提示,需保证是正确的实现,并且最好是官方推荐或者使用人数较多的库,用以确保使用的安全性。

代码

import Foundation
import var CommonCrypto.CC_SHA224_DIGEST_LENGTH
import func CommonCrypto.CC_SHA224
import typealias CommonCrypto.CC_LONG

import var CommonCrypto.CC_SHA256_DIGEST_LENGTH
import func CommonCrypto.CC_SHA256
import typealias CommonCrypto.CC_LONG

import var CommonCrypto.CC_SHA384_DIGEST_LENGTH
import func CommonCrypto.CC_SHA384
import typealias CommonCrypto.CC_LONG

import var CommonCrypto.CC_SHA512_DIGEST_LENGTH
import func CommonCrypto.CC_SHA512
import typealias CommonCrypto.CC_LONG

func SHA224(message: String) -> String {
    let messageData = message.data(using: .utf8)!
    var digestData = Data(countInt(CC_SHA224_DIGEST_LENGTH))
    _ = digestData.withUnsafeMutableBytes { digestBytes -> UInt8 in
        messageData.withUnsafeBytes { messageBytes -> UInt8 in
            if let messageBytesBaseAddress = messageBytes.baseAddress, let digestBytesBlindMemory = digestBytes.bindMemory(to: UInt8.self).baseAddress {
                let messageLength = CC_LONG(messageData.count)
                CC_SHA224(messageBytesBaseAddress, messageLength, digestBytesBlindMemory)
            }
            return 0
        }
    }
    return digestData.map {
                String(format: "%02hhx", $0)
            }
            .joined()
}

func SHA256(message: String) -> String {
    let messageData = message.data(using: .utf8)!
    var digestData = Data(countInt(CC_SHA256_DIGEST_LENGTH))
    _ = digestData.withUnsafeMutableBytes { digestBytes -> UInt8 in
        messageData.withUnsafeBytes { messageBytes -> UInt8 in
            if let messageBytesBaseAddress = messageBytes.baseAddress, let digestBytesBlindMemory = digestBytes.bindMemory(to: UInt8.self).baseAddress {
                let messageLength = CC_LONG(messageData.count)
                CC_SHA256(messageBytesBaseAddress, messageLength, digestBytesBlindMemory)
            }
            return 0
        }
    }
    return digestData.map {
                String(format: "%02hhx", $0)
            }
            .joined()
}

func SHA384(message: String) -> String {
    let messageData = message.data(using: .utf8)!
    var digestData = Data(countInt(CC_SHA384_DIGEST_LENGTH))
    _ = digestData.withUnsafeMutableBytes { digestBytes -> UInt8 in
        messageData.withUnsafeBytes { messageBytes -> UInt8 in
            if let messageBytesBaseAddress = messageBytes.baseAddress, let digestBytesBlindMemory = digestBytes.bindMemory(to: UInt8.self).baseAddress {
                let messageLength = CC_LONG(messageData.count)
                CC_SHA384(messageBytesBaseAddress, messageLength, digestBytesBlindMemory)
            }
            return 0
        }
    }
    return digestData.map {
                String(format: "%02hhx", $0)
            }
            .joined()
}

func SHA512(message: String) -> String {
    let messageData = message.data(using: .utf8)!
    var digestData = Data(countInt(CC_SHA512_DIGEST_LENGTH))
    _ = digestData.withUnsafeMutableBytes { digestBytes -> UInt8 in
        messageData.withUnsafeBytes { messageBytes -> UInt8 in
            if let messageBytesBaseAddress = messageBytes.baseAddress, let digestBytesBlindMemory = digestBytes.bindMemory(to: UInt8.self).baseAddress {
                let messageLength = CC_LONG(messageData.count)
                CC_SHA512(messageBytesBaseAddress, messageLength, digestBytesBlindMemory)
            }
            return 0
        }
    }
    return digestData.map {
                String(format: "%02hhx", $0)
            }
            .joined()
}

使用样例

import XCTest

final class cryptography_demoTestsXCTestCase {
    func testExample() throws {
        print(SHA224(message: ""))
        print(SHA224(message: "Hello, world!"))
        print(SHA224(message: "The quick brown fox jumps over the lazy dog."))

        print(SHA256(message: ""))
        print(SHA256(message: "Hello, world!"))
        print(SHA256(message: "The quick brown fox jumps over the lazy dog."))

        print(SHA384(message: ""))
        print(SHA384(message: "Hello, world!"))
        print(SHA384(message: "The quick brown fox jumps over the lazy dog."))

        print(SHA512(message: ""))
        print(SHA512(message: "Hello, world!"))
        print(SHA512(message: "The quick brown fox jumps over the lazy dog."))
    }
}

VB DotNet

📌目前VB DotNet暂未找到合适的sha224sha512_224sha512_256的调用,自带的函数不带这些,如果读者有好的库可以使用,欢迎和我交流,提示,需保证是正确的实现,并且最好是官方推荐或者使用人数较多的库,用以确保使用的安全性。

代码

Imports System.Security.Cryptography
Imports System.Text

Public Class Application
Private Shared Function Sha256Hash(message As String) As String
Using hasher As SHA256 = SHA256.Create()
Dim bytes As Byte() =
hasher.ComputeHash(Encoding.UTF8.GetBytes(message))

Dim sBuilder As New StringBuilder()

For n As Integer = 0 To bytes.Length - 1
sBuilder.Append(bytes(n).ToString("x2"))
Next n

Return sBuilder.ToString()
End Using
End Function

Private Shared Function Sha384Hash(message As String) As String
Using hasher As SHA384 = SHA384.Create()
Dim bytes As Byte() =
hasher.ComputeHash(Encoding.UTF8.GetBytes(message))

Dim sBuilder As New StringBuilder()

For n As Integer = 0 To bytes.Length - 1
sBuilder.Append(bytes(n).ToString("x2"))
Next n

Return sBuilder.ToString()
End Using
End Function

Private Shared Function Sha512Hash(message As String) As String
Using hasher As SHA512 = SHA512.Create()
Dim bytes As Byte() =
hasher.ComputeHash(Encoding.UTF8.GetBytes(message))

Dim sBuilder As New StringBuilder()

For n As Integer = 0 To bytes.Length - 1
sBuilder.Append(bytes(n).ToString("x2"))
Next n

Return sBuilder.ToString()
End Using
End Function
End Class

使用样例

Imports System.Security.Cryptography
Imports System.Text

Public Class Application
Public Shared Sub Main()
System.Console.WriteLine(Sha256Hash(""))
System.Console.WriteLine(Sha256Hash("Hello, world!"))
System.Console.WriteLine(Sha256Hash("The quick brown fox jumps over the lazy dog."))

System.Console.WriteLine(Sha384Hash(""))
System.Console.WriteLine(Sha384Hash("Hello, world!"))
System.Console.WriteLine(Sha384Hash("The quick brown fox jumps over the lazy dog."))

System.Console.WriteLine(Sha512Hash(""))
System.Console.WriteLine(Sha512Hash("Hello, world!"))
System.Console.WriteLine(Sha512Hash("The quick brown fox jumps over the lazy dog."))
End Sub
End Class

说明

📌目前优先采用语言内部实现,引入的外部依赖会给出并指定版本,如果我对某些源码产生的修改,会优先遵从原始库的写法风格,并且会给出,由于个人水平有限,大家在使用我修改后或者实现的方案的时候,用于生产用途,建议自行研判一下安全性,建议大家使用标准实现,采用官方推荐或者使用人数较多的库用于生产环境,以保证安全性,因为个人水平有限,因此有些库可能用的不合适,如果读者觉得不合适,欢迎指出,如果读者有推荐使用的库,欢迎和我交流,注意,交流的时候建议提供完整的语言版本,库版本,以及使用方法和样例,最好是带文档,并且开源的库,并前期自行验证下实现是不是正确的,因为有些实现出来的算法用的标准不一样,可能会存在差异,如果有差异,最好可以提供对应的rfc或者paper,在这里先感谢各位读者大佬们了,最终愿大家加班不再有。


原文始发于微信公众号(Coder小Q):【加班不再有】SHA2

特别标注: 本站(CN-SEC.COM)所有文章仅供技术研究,若将其信息做其他用途,由用户承担全部法律及连带责任,本站不承担任何法律及连带责任,请遵守中华人民共和国安全法.
  • 我的微信
  • 微信扫一扫
  • weinxin
  • 我的微信公众号
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2022年11月30日00:01:10
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出):
                  【加班不再有】SHA2 http://cn-sec.com/archives/1434624.html

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: