Ekdohibs
/
zig
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
zig/std/crypto/index.zig

45 lines
1.3 KiB
Zig
Raw Normal View History

Fix crypto exports
2018-01-16 22:10:27 -08:00
pub const Md5 = @import("md5.zig").Md5;
pub const Sha1 = @import("sha1.zig").Sha1;
Add Sha2 functions We take the fastest time measurement taken across multiple runs. Tested across multiple compiler flags and the best chosen. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Gcc: 7.2.1 20171224 Clang: 5.0.1 Zig: 0.1.1.304f6f1d ``` See https://www.nayuki.io/page/fast-sha2-hashes-in-x86-assembly. ``` Gcc -O2 219 Mb/s Clang -O2 213 Mb/s Zig --release-fast 284 Mb/s Zig --release-safe 211 Mb/s Zig 6 Mb/s ``` ``` Gcc -O2 350 Mb/s Clang -O2 354 Mb/s Zig --release-fast 426 Mb/s Zig --release-safe 300 Mb/s Zig 11 Mb/s ```
2018-01-13 01:23:12 -08:00
const sha2 = @import("sha2.zig");
pub const Sha224 = sha2.Sha224;
pub const Sha256 = sha2.Sha256;
pub const Sha384 = sha2.Sha384;
pub const Sha512 = sha2.Sha512;
Add Md5 and Sha1 hash functions Some performance comparisons to C. We take the fastest time measurement taken across multiple runs. The block hashing functions use the same md5/sha1 methods. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Gcc: 7.2.1 20171224 Clang: 5.0.1 Zig: 0.1.1.304f6f1d ``` See https://www.nayuki.io/page/fast-md5-hash-implementation-in-x86-assembly: ``` gcc -O2 661 Mb/s clang -O2 490 Mb/s zig --release-fast and zig --release-safe 570 Mb/s zig 50 Mb/s ``` See https://www.nayuki.io/page/fast-sha1-hash-implementation-in-x86-assembly: ``` gcc -O2 588 Mb/s clang -O2 563 Mb/s zig --release-fast and zig --release-safe 610 Mb/s zig 21 Mb/s ``` In short, zig provides pretty useful tools for writing this sort of code. We are in the lead against clang (which uses the same LLVM backend) with us being slower only against md5 with GCC.
2018-01-12 17:40:21 -08:00
Add Sha3 hashing functions These are on the slower side and could be improved. No performance optimizations yet have been done. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz ``` -- Sha3-256 ``` Zig --release-fast 93 Mb/s Zig --release-safe 99 Mb/s Zig 4 Mb/s ``` -- Sha3-512 ``` Zig --release-fast 49 Mb/s Zig --release-safe 54 Mb/s Zig 2 Mb/s ``` Interestingly, release-safe is producing slightly better code than release-fast.
2018-01-16 22:40:50 -08:00
const sha3 = @import("sha3.zig");
pub const Sha3_224 = sha3.Sha3_224;
pub const Sha3_256 = sha3.Sha3_256;
pub const Sha3_384 = sha3.Sha3_384;
pub const Sha3_512 = sha3.Sha3_512;
Change crypto functions to fill a buffer - Rename blake2x -> blake2 - Fix blake2s truncated tests
2018-01-16 00:35:31 -08:00
const blake2 = @import("blake2.zig");
pub const Blake2s224 = blake2.Blake2s224;
pub const Blake2s256 = blake2.Blake2s256;
pub const Blake2b384 = blake2.Blake2b384;
pub const Blake2b512 = blake2.Blake2b512;
Add Blake2X hash functions The truncated output variants currently are dependent on a more complete bigint implementation in the compiler.
2018-01-15 02:14:13 -08:00
Add Hmac function (#890)
2018-04-04 07:31:10 -07:00
const hmac = @import("hmac.zig");
pub const HmacMd5 = hmac.HmacMd5;
Make poly1305 and x25519 more idiomatic zig This also adjusts the current hash/hmac functions to have a consistent interface allowing easier switching/testing.
2018-08-30 23:40:09 -07:00
pub const HmacSha1 = hmac.HmacSha1;
pub const HmacSha256 = hmac.HmacSha256;
Add Hmac function (#890)
2018-04-04 07:31:10 -07:00
std.crypto: add chaCha20 v3
2018-08-10 19:01:37 -07:00
const import_chaCha20 = @import("chacha20.zig");
pub const chaCha20IETF = import_chaCha20.chaCha20IETF;
pub const chaCha20With64BitNonce = import_chaCha20.chaCha20With64BitNonce;
Make poly1305 and x25519 more idiomatic zig This also adjusts the current hash/hmac functions to have a consistent interface allowing easier switching/testing.
2018-08-30 23:40:09 -07:00
pub const Poly1305 = @import("poly1305.zig").Poly1305;
pub const X25519 = @import("x25519.zig").X25519;
Add poly1305 and x25519 crypto primitives These are translated from [monocypher](https://monocypher.org/) which has fairly competitive performance while remaining quite simple. Initial performance comparision: Zig: Poly1305: 1423 MiB/s X25519: 8671 exchanges per second Monocypher: Poly1305: 1567 MiB/s X25519: 10539 exchanges per second There is room for improvement and no real effort has been made at all in optimization beyond a direct translation.
2018-08-29 23:02:19 -07:00
Add Md5 and Sha1 hash functions Some performance comparisons to C. We take the fastest time measurement taken across multiple runs. The block hashing functions use the same md5/sha1 methods. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Gcc: 7.2.1 20171224 Clang: 5.0.1 Zig: 0.1.1.304f6f1d ``` See https://www.nayuki.io/page/fast-md5-hash-implementation-in-x86-assembly: ``` gcc -O2 661 Mb/s clang -O2 490 Mb/s zig --release-fast and zig --release-safe 570 Mb/s zig 50 Mb/s ``` See https://www.nayuki.io/page/fast-sha1-hash-implementation-in-x86-assembly: ``` gcc -O2 588 Mb/s clang -O2 563 Mb/s zig --release-fast and zig --release-safe 610 Mb/s zig 21 Mb/s ``` In short, zig provides pretty useful tools for writing this sort of code. We are in the lead against clang (which uses the same LLVM backend) with us being slower only against md5 with GCC.
2018-01-12 17:40:21 -08:00
test "crypto" {
std/crypto: Clean up poly1305/x25519
2018-09-04 01:16:12 -07:00
_ = @import("blake2.zig");
_ = @import("chacha20.zig");
_ = @import("hmac.zig");
Add Md5 and Sha1 hash functions Some performance comparisons to C. We take the fastest time measurement taken across multiple runs. The block hashing functions use the same md5/sha1 methods. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Gcc: 7.2.1 20171224 Clang: 5.0.1 Zig: 0.1.1.304f6f1d ``` See https://www.nayuki.io/page/fast-md5-hash-implementation-in-x86-assembly: ``` gcc -O2 661 Mb/s clang -O2 490 Mb/s zig --release-fast and zig --release-safe 570 Mb/s zig 50 Mb/s ``` See https://www.nayuki.io/page/fast-sha1-hash-implementation-in-x86-assembly: ``` gcc -O2 588 Mb/s clang -O2 563 Mb/s zig --release-fast and zig --release-safe 610 Mb/s zig 21 Mb/s ``` In short, zig provides pretty useful tools for writing this sort of code. We are in the lead against clang (which uses the same LLVM backend) with us being slower only against md5 with GCC.
2018-01-12 17:40:21 -08:00
_ = @import("md5.zig");
std/crypto: Clean up poly1305/x25519
2018-09-04 01:16:12 -07:00
_ = @import("poly1305.zig");
Add Md5 and Sha1 hash functions Some performance comparisons to C. We take the fastest time measurement taken across multiple runs. The block hashing functions use the same md5/sha1 methods. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Gcc: 7.2.1 20171224 Clang: 5.0.1 Zig: 0.1.1.304f6f1d ``` See https://www.nayuki.io/page/fast-md5-hash-implementation-in-x86-assembly: ``` gcc -O2 661 Mb/s clang -O2 490 Mb/s zig --release-fast and zig --release-safe 570 Mb/s zig 50 Mb/s ``` See https://www.nayuki.io/page/fast-sha1-hash-implementation-in-x86-assembly: ``` gcc -O2 588 Mb/s clang -O2 563 Mb/s zig --release-fast and zig --release-safe 610 Mb/s zig 21 Mb/s ``` In short, zig provides pretty useful tools for writing this sort of code. We are in the lead against clang (which uses the same LLVM backend) with us being slower only against md5 with GCC.
2018-01-12 17:40:21 -08:00
_ = @import("sha1.zig");
Add Sha2 functions We take the fastest time measurement taken across multiple runs. Tested across multiple compiler flags and the best chosen. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Gcc: 7.2.1 20171224 Clang: 5.0.1 Zig: 0.1.1.304f6f1d ``` See https://www.nayuki.io/page/fast-sha2-hashes-in-x86-assembly. ``` Gcc -O2 219 Mb/s Clang -O2 213 Mb/s Zig --release-fast 284 Mb/s Zig --release-safe 211 Mb/s Zig 6 Mb/s ``` ``` Gcc -O2 350 Mb/s Clang -O2 354 Mb/s Zig --release-fast 426 Mb/s Zig --release-safe 300 Mb/s Zig 11 Mb/s ```
2018-01-13 01:23:12 -08:00
_ = @import("sha2.zig");
Add Sha3 hashing functions These are on the slower side and could be improved. No performance optimizations yet have been done. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz ``` -- Sha3-256 ``` Zig --release-fast 93 Mb/s Zig --release-safe 99 Mb/s Zig 4 Mb/s ``` -- Sha3-512 ``` Zig --release-fast 49 Mb/s Zig --release-safe 54 Mb/s Zig 2 Mb/s ``` Interestingly, release-safe is producing slightly better code than release-fast.
2018-01-16 22:40:50 -08:00
_ = @import("sha3.zig");
Add poly1305 and x25519 crypto primitives These are translated from [monocypher](https://monocypher.org/) which has fairly competitive performance while remaining quite simple. Initial performance comparision: Zig: Poly1305: 1423 MiB/s X25519: 8671 exchanges per second Monocypher: Poly1305: 1567 MiB/s X25519: 10539 exchanges per second There is room for improvement and no real effort has been made at all in optimization beyond a direct translation.
2018-08-29 23:02:19 -07:00
_ = @import("x25519.zig");
Add Md5 and Sha1 hash functions Some performance comparisons to C. We take the fastest time measurement taken across multiple runs. The block hashing functions use the same md5/sha1 methods. ``` Cpu: Intel(R) Core(TM) i5-6500 CPU @ 3.20GHz Gcc: 7.2.1 20171224 Clang: 5.0.1 Zig: 0.1.1.304f6f1d ``` See https://www.nayuki.io/page/fast-md5-hash-implementation-in-x86-assembly: ``` gcc -O2 661 Mb/s clang -O2 490 Mb/s zig --release-fast and zig --release-safe 570 Mb/s zig 50 Mb/s ``` See https://www.nayuki.io/page/fast-sha1-hash-implementation-in-x86-assembly: ``` gcc -O2 588 Mb/s clang -O2 563 Mb/s zig --release-fast and zig --release-safe 610 Mb/s zig 21 Mb/s ``` In short, zig provides pretty useful tools for writing this sort of code. We are in the lead against clang (which uses the same LLVM backend) with us being slower only against md5 with GCC.
2018-01-12 17:40:21 -08:00
}