📚 SHA-224 Libraries Directory

Comprehensive collection of verified SHA-224 implementations

50+
Libraries
15+
Languages
100%
Verified
All Official Popular Hardware Accelerated Streaming Support Browser Compatible
🐍
Python
5 libraries
hashlib Built-in
Official Verified Maintained

Python's built-in cryptographic hash library. Provides SHA-224 through OpenSSL backend with excellent performance.

⭐ Core Library 📦 No Install 🚀 Fast
import hashlib Copied!
Quick Start
import hashlib # String hashing text = "Hello, World!" hash_object = hashlib.sha224(text.encode()) hex_dig = hash_object.hexdigest() print(hex_dig) # File hashing def hash_file(filename): sha224 = hashlib.sha224() with open(filename, 'rb') as f: for chunk in iter(lambda: f.read(4096), b""): sha224.update(chunk) return sha224.hexdigest()
cryptography v41.0.0
Popular Verified

Modern cryptography library for Python with both high-level recipes and low-level interfaces to common cryptographic algorithms.

⭐ 5.8k 📦 100M+/mo 🔄 Active
pip install cryptography Copied!
Documentation GitHub
PyCryptodome v3.19.0
Popular Maintained

Self-contained Python package of low-level cryptographic primitives. Drop-in replacement for PyCrypto.

⭐ 2.5k 📦 50M+/mo
pip install pycryptodome Copied!
📜
JavaScript / Node.js
6 libraries
Node.js Crypto Built-in
Official Verified

Node.js built-in crypto module providing cryptographic functionality including SHA-224 hashing.

⭐ Core Module 🚀 Native Speed
const crypto = require('crypto'); Copied!
Quick Start
const crypto = require('crypto'); // String hashing const hash = crypto.createHash('sha224') .update('Hello, World!') .digest('hex'); // Stream hashing const fs = require('fs'); const hash = crypto.createHash('sha224'); const stream = fs.createReadStream('file.txt'); stream.on('data', data => hash.update(data)); stream.on('end', () => console.log(hash.digest('hex')));
WebCrypto API Native
Browser Native W3C Standard

Native browser API for performing cryptographic operations including SHA-224 hashing.

🌐 All Browsers 🚀 Native Speed
crypto.subtle.digest('SHA-224', data) Copied!
Quick Start
async function sha224(message) { const msgBuffer = new TextEncoder().encode(message); const hashBuffer = await crypto.subtle.digest('SHA-224', msgBuffer); const hashArray = Array.from(new Uint8Array(hashBuffer)); const hashHex = hashArray .map(b => b.toString(16).padStart(2, '0')) .join(''); return hashHex; } // Usage sha224('Hello, World!').then(console.log);
crypto-js v4.2.0
Popular Maintained

JavaScript library of crypto standards. Works in browsers and Node.js.

⭐ 15k 📦 4M+/week
npm install crypto-js Copied!
GitHub NPM
@noble/hashes v1.3.2
Audited Zero Dependencies

High-security, easily auditable, 0-dependency cryptographic hashes for JavaScript.

⭐ 500+ 🔒 Secure
npm install @noble/hashes Copied!
☕
Java
4 libraries
java.security Built-in
Official JDK Standard

Java's built-in security package providing SHA-224 through MessageDigest class.

⭐ Core Library 🚀 Native
import java.security.MessageDigest; Copied!
Quick Start
import java.security.MessageDigest; import javax.xml.bind.DatatypeConverter; public class SHA224Example { public static String hash(String input) throws Exception { MessageDigest md = MessageDigest.getInstance("SHA-224"); byte[] digest = md.digest(input.getBytes("UTF-8")); return DatatypeConverter.printHexBinary(digest).toLowerCase(); } }
Bouncy Castle v1.76
Popular Enterprise

Comprehensive Java cryptography APIs supporting SHA-224 and many other algorithms.

⭐ 2k+ 🏢 Enterprise
implementation 'org.bouncycastle:bcprov-jdk18on:1.76' Copied!
Apache Commons Codec v1.16
Apache Stable

Apache Commons library providing implementations of common encoders and decoders including SHA-224.

⭐ Apache 📦 Maven Central
implementation 'commons-codec:commons-codec:1.16' Copied!
🐹
Go
2 libraries
crypto/sha256 Built-in
Official Standard Library

Go's standard library crypto package providing SHA-224 (via sha256.New224).

⭐ Core Library 🚀 Fast
import "crypto/sha256" Copied!
Quick Start
package main import ( "crypto/sha256" "encoding/hex" "fmt" ) func main() { data := []byte("Hello, World!") hash := sha256.Sum224(data) hashString := hex.EncodeToString(hash[:]) fmt.Println(hashString) }
⚙️
C / C++
3 libraries
OpenSSL v3.1.0
Industry Standard Hardware Accel

Full-featured toolkit for TLS and SSL protocols, also a general-purpose cryptography library with SHA-224 support.

⭐ 23k+ ⚡ HW Optimized
apt-get install libssl-dev Copied!
Quick Start
#include <openssl/sha.h> #include <stdio.h> void sha224_hash(const char *string, char outputBuffer[57]) { unsigned char hash[SHA224_DIGEST_LENGTH]; SHA224_CTX sha224; SHA224_Init(&sha224); SHA224_Update(&sha224, string, strlen(string)); SHA224_Final(hash, &sha224); for(int i = 0; i < SHA224_DIGEST_LENGTH; i++) { sprintf(outputBuffer + (i * 2), "%02x", hash[i]); } outputBuffer[56] = 0; }
crypto-algorithms v1.0
Lightweight Embedded

Basic implementations of standard cryptography algorithms, suitable for embedded systems.

⭐ 1.4k 🔬 Educational
git clone https://github.com/B-Con/crypto-algorithms Copied!
🌍
Other Languages
10+ languages
Language Library Installation Native Hardware Accel
Ruby Digest::SHA2 require 'digest' ✓ ✓
PHP hash() Built-in (PHP 5.1.2+) ✓ ✓
Rust sha2 crate cargo add sha2 ✓ ✓
C#/.NET System.Security.Cryptography Built-in ✓ ✓
Swift CryptoKit import CryptoKit ✓ ✓
Kotlin java.security Built-in (JVM) ✓ ✗
Perl Digest::SHA cpan Digest::SHA ✓ ✓
Elixir :crypto Built-in (Erlang) ✓ ✓

📦 Package Manager Quick Reference

NPM (Node.js): npm install [package]
pip (Python): pip install [package]
Maven (Java): Add to pom.xml
Go Modules: go get [package]
Cargo (Rust): cargo add [package]
NuGet (.NET): dotnet add package
🎯
Library Selection Guide

Choose Based on Your Needs:

  • Maximum Performance: OpenSSL, Node.js Crypto, .NET Cryptography
  • Browser Compatibility: WebCrypto API, crypto-js, @noble/hashes
  • Zero Dependencies: Built-in libraries (hashlib, crypto, java.security)
  • Hardware Acceleration: OpenSSL, CryptoKit, Intel ISA-L
  • Educational/Learning: crypto-algorithms, simple implementations
  • Enterprise/Compliance: Bouncy Castle, OpenSSL, FIPS-validated modules

Performance Comparison:

Library Type Relative Speed Use Case
Hardware Accelerated 10x High-throughput servers
Native/Compiled 5x General applications
WebAssembly 2x Browser performance
Pure JS/Python 1x (baseline) Prototyping, learning