mirror of
https://github.com/ziglang/zig.git
synced 2024-11-27 07:32:44 +00:00
Merge remote-tracking branch 'origin/master' into stage2-zig-cc
This commit is contained in:
Andrew Kelley
commit
b811a99af9
@ -28,6 +28,8 @@ pub const aead = struct {
|
||||
pub const Gimli = @import("crypto/gimli.zig").Aead;
|
||||
pub const ChaCha20Poly1305 = chacha20.Chacha20Poly1305;
|
||||
pub const XChaCha20Poly1305 = chacha20.XChacha20Poly1305;
|
||||
pub const AEGIS128L = @import("crypto/aegis.zig").AEGIS128L;
|
||||
pub const AEGIS256 = @import("crypto/aegis.zig").AEGIS256;
|
||||
};
|
||||
|
||||
/// MAC functions requiring single-use secret keys.
|
||||
|
||||
447
lib/std/crypto/aegis.zig
Normal file
447
lib/std/crypto/aegis.zig
Normal file
@ -0,0 +1,447 @@
|
||||
const std = @import("std");
|
||||
const mem = std.mem;
|
||||
const assert = std.debug.assert;
|
||||
const AESBlock = std.crypto.core.aes.Block;
|
||||
|
||||
const State128L = struct {
|
||||
blocks: [8]AESBlock,
|
||||
|
||||
fn init(key: [16]u8, nonce: [16]u8) State128L {
|
||||
const c1 = AESBlock.fromBytes(&[16]u8{ 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1, 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd });
|
||||
const c2 = AESBlock.fromBytes(&[16]u8{ 0x0, 0x1, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62 });
|
||||
const key_block = AESBlock.fromBytes(&key);
|
||||
const nonce_block = AESBlock.fromBytes(&nonce);
|
||||
const blocks = [8]AESBlock{
|
||||
key_block.xorBlocks(nonce_block),
|
||||
c1,
|
||||
c2,
|
||||
c1,
|
||||
key_block.xorBlocks(nonce_block),
|
||||
key_block.xorBlocks(c2),
|
||||
key_block.xorBlocks(c1),
|
||||
key_block.xorBlocks(c2),
|
||||
};
|
||||
var state = State128L{ .blocks = blocks };
|
||||
var i: usize = 0;
|
||||
while (i < 10) : (i += 1) {
|
||||
state.update(nonce_block, key_block);
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
inline fn update(state: *State128L, d1: AESBlock, d2: AESBlock) void {
|
||||
const blocks = &state.blocks;
|
||||
const tmp = blocks[7];
|
||||
comptime var i: usize = 7;
|
||||
inline while (i > 0) : (i -= 1) {
|
||||
blocks[i] = blocks[i - 1].encrypt(blocks[i]);
|
||||
}
|
||||
blocks[0] = tmp.encrypt(blocks[0]);
|
||||
blocks[0] = blocks[0].xorBlocks(d1);
|
||||
blocks[4] = blocks[4].xorBlocks(d2);
|
||||
}
|
||||
|
||||
fn enc(state: *State128L, dst: *[32]u8, src: *const [32]u8) void {
|
||||
const blocks = &state.blocks;
|
||||
const msg0 = AESBlock.fromBytes(src[0..16]);
|
||||
const msg1 = AESBlock.fromBytes(src[16..32]);
|
||||
var tmp0 = msg0.xorBlocks(blocks[6]).xorBlocks(blocks[1]);
|
||||
var tmp1 = msg1.xorBlocks(blocks[2]).xorBlocks(blocks[5]);
|
||||
tmp0 = tmp0.xorBlocks(blocks[2].andBlocks(blocks[3]));
|
||||
tmp1 = tmp1.xorBlocks(blocks[6].andBlocks(blocks[7]));
|
||||
dst[0..16].* = tmp0.toBytes();
|
||||
dst[16..32].* = tmp1.toBytes();
|
||||
state.update(msg0, msg1);
|
||||
}
|
||||
|
||||
fn dec(state: *State128L, dst: *[32]u8, src: *const [32]u8) void {
|
||||
const blocks = &state.blocks;
|
||||
var msg0 = AESBlock.fromBytes(src[0..16]).xorBlocks(blocks[6]).xorBlocks(blocks[1]);
|
||||
var msg1 = AESBlock.fromBytes(src[16..32]).xorBlocks(blocks[2]).xorBlocks(blocks[5]);
|
||||
msg0 = msg0.xorBlocks(blocks[2].andBlocks(blocks[3]));
|
||||
msg1 = msg1.xorBlocks(blocks[6].andBlocks(blocks[7]));
|
||||
dst[0..16].* = msg0.toBytes();
|
||||
dst[16..32].* = msg1.toBytes();
|
||||
state.update(msg0, msg1);
|
||||
}
|
||||
|
||||
fn mac(state: *State128L, adlen: usize, mlen: usize) [16]u8 {
|
||||
const blocks = &state.blocks;
|
||||
var sizes: [16]u8 = undefined;
|
||||
mem.writeIntLittle(u64, sizes[0..8], adlen * 8);
|
||||
mem.writeIntLittle(u64, sizes[8..16], mlen * 8);
|
||||
const tmp = AESBlock.fromBytes(&sizes).xorBlocks(blocks[2]);
|
||||
var i: usize = 0;
|
||||
while (i < 7) : (i += 1) {
|
||||
state.update(tmp, tmp);
|
||||
}
|
||||
return blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).
|
||||
xorBlocks(blocks[5]).xorBlocks(blocks[6]).toBytes();
|
||||
}
|
||||
};
|
||||
|
||||
/// AEGIS is a very fast authenticated encryption system built on top of the core AES function.
|
||||
///
|
||||
/// The 128L variant of AEGIS has a 128 bit key, a 128 bit nonce, and processes 256 bit message blocks.
|
||||
/// It was designed to fully exploit the parallelism and built-in AES support of recent Intel and ARM CPUs.
|
||||
///
|
||||
/// https://competitions.cr.yp.to/round3/aegisv11.pdf
|
||||
pub const AEGIS128L = struct {
|
||||
pub const tag_length = 16;
|
||||
pub const nonce_length = 16;
|
||||
pub const key_length = 16;
|
||||
|
||||
/// c: ciphertext: output buffer should be of size m.len
|
||||
/// tag: authentication tag: output MAC
|
||||
/// m: message
|
||||
/// ad: Associated Data
|
||||
/// npub: public nonce
|
||||
/// k: private key
|
||||
pub fn encrypt(c: []u8, tag: *[tag_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) void {
|
||||
assert(c.len == m.len);
|
||||
var state = State128L.init(key, npub);
|
||||
var src: [32]u8 align(16) = undefined;
|
||||
var dst: [32]u8 align(16) = undefined;
|
||||
var i: usize = 0;
|
||||
while (i + 32 <= ad.len) : (i += 32) {
|
||||
state.enc(&dst, ad[i..][0..32]);
|
||||
}
|
||||
if (ad.len % 32 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. ad.len % 32], ad[i .. i + ad.len % 32]);
|
||||
state.enc(&dst, &src);
|
||||
}
|
||||
i = 0;
|
||||
while (i + 32 <= m.len) : (i += 32) {
|
||||
state.enc(c[i..][0..32], m[i..][0..32]);
|
||||
}
|
||||
if (m.len % 32 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. m.len % 32], m[i .. i + m.len % 32]);
|
||||
state.enc(&dst, &src);
|
||||
mem.copy(u8, c[i .. i + m.len % 32], dst[0 .. m.len % 32]);
|
||||
}
|
||||
tag.* = state.mac(ad.len, m.len);
|
||||
}
|
||||
|
||||
/// m: message: output buffer should be of size c.len
|
||||
/// c: ciphertext
|
||||
/// tag: authentication tag
|
||||
/// ad: Associated Data
|
||||
/// npub: public nonce
|
||||
/// k: private key
|
||||
pub fn decrypt(m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) !void {
|
||||
assert(c.len == m.len);
|
||||
var state = State128L.init(key, npub);
|
||||
var src: [32]u8 align(16) = undefined;
|
||||
var dst: [32]u8 align(16) = undefined;
|
||||
var i: usize = 0;
|
||||
while (i + 32 <= ad.len) : (i += 32) {
|
||||
state.enc(&dst, ad[i..][0..32]);
|
||||
}
|
||||
if (ad.len % 32 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. ad.len % 32], ad[i .. i + ad.len % 32]);
|
||||
state.enc(&dst, &src);
|
||||
}
|
||||
i = 0;
|
||||
while (i + 32 <= m.len) : (i += 32) {
|
||||
state.dec(m[i..][0..32], c[i..][0..32]);
|
||||
}
|
||||
if (m.len % 32 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. m.len % 32], c[i .. i + m.len % 32]);
|
||||
state.dec(&dst, &src);
|
||||
mem.copy(u8, m[i .. i + m.len % 32], dst[0 .. m.len % 32]);
|
||||
mem.set(u8, dst[0 .. m.len % 32], 0);
|
||||
const blocks = &state.blocks;
|
||||
blocks[0] = blocks[0].xorBlocks(AESBlock.fromBytes(dst[0..16]));
|
||||
blocks[4] = blocks[4].xorBlocks(AESBlock.fromBytes(dst[16..32]));
|
||||
}
|
||||
const computed_tag = state.mac(ad.len, m.len);
|
||||
var acc: u8 = 0;
|
||||
for (computed_tag) |_, j| {
|
||||
acc |= (computed_tag[j] ^ tag[j]);
|
||||
}
|
||||
if (acc != 0) {
|
||||
mem.set(u8, m, 0xaa);
|
||||
return error.AuthenticationFailed;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const State256 = struct {
|
||||
blocks: [6]AESBlock,
|
||||
|
||||
fn init(key: [32]u8, nonce: [32]u8) State256 {
|
||||
const c1 = AESBlock.fromBytes(&[16]u8{ 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1, 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd });
|
||||
const c2 = AESBlock.fromBytes(&[16]u8{ 0x0, 0x1, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62 });
|
||||
const key_block1 = AESBlock.fromBytes(key[0..16]);
|
||||
const key_block2 = AESBlock.fromBytes(key[16..32]);
|
||||
const nonce_block1 = AESBlock.fromBytes(nonce[0..16]);
|
||||
const nonce_block2 = AESBlock.fromBytes(nonce[16..32]);
|
||||
const kxn1 = key_block1.xorBlocks(nonce_block1);
|
||||
const kxn2 = key_block2.xorBlocks(nonce_block2);
|
||||
const blocks = [6]AESBlock{
|
||||
kxn1,
|
||||
kxn2,
|
||||
c1,
|
||||
c2,
|
||||
key_block1.xorBlocks(c2),
|
||||
key_block2.xorBlocks(c1),
|
||||
};
|
||||
var state = State256{ .blocks = blocks };
|
||||
var i: usize = 0;
|
||||
while (i < 4) : (i += 1) {
|
||||
state.update(key_block1);
|
||||
state.update(key_block2);
|
||||
state.update(kxn1);
|
||||
state.update(kxn2);
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
inline fn update(state: *State256, d: AESBlock) void {
|
||||
const blocks = &state.blocks;
|
||||
const tmp = blocks[5].encrypt(blocks[0]);
|
||||
comptime var i: usize = 5;
|
||||
inline while (i > 0) : (i -= 1) {
|
||||
blocks[i] = blocks[i - 1].encrypt(blocks[i]);
|
||||
}
|
||||
blocks[0] = tmp.xorBlocks(d);
|
||||
}
|
||||
|
||||
fn enc(state: *State256, dst: *[16]u8, src: *const [16]u8) void {
|
||||
const blocks = &state.blocks;
|
||||
const msg = AESBlock.fromBytes(src);
|
||||
var tmp = msg.xorBlocks(blocks[5]).xorBlocks(blocks[4]).xorBlocks(blocks[1]);
|
||||
tmp = tmp.xorBlocks(blocks[2].andBlocks(blocks[3]));
|
||||
dst.* = tmp.toBytes();
|
||||
state.update(msg);
|
||||
}
|
||||
|
||||
fn dec(state: *State256, dst: *[16]u8, src: *const [16]u8) void {
|
||||
const blocks = &state.blocks;
|
||||
var msg = AESBlock.fromBytes(src).xorBlocks(blocks[5]).xorBlocks(blocks[4]).xorBlocks(blocks[1]);
|
||||
msg = msg.xorBlocks(blocks[2].andBlocks(blocks[3]));
|
||||
dst.* = msg.toBytes();
|
||||
state.update(msg);
|
||||
}
|
||||
|
||||
fn mac(state: *State256, adlen: usize, mlen: usize) [16]u8 {
|
||||
const blocks = &state.blocks;
|
||||
var sizes: [16]u8 = undefined;
|
||||
mem.writeIntLittle(u64, sizes[0..8], adlen * 8);
|
||||
mem.writeIntLittle(u64, sizes[8..16], mlen * 8);
|
||||
const tmp = AESBlock.fromBytes(&sizes).xorBlocks(blocks[3]);
|
||||
var i: usize = 0;
|
||||
while (i < 7) : (i += 1) {
|
||||
state.update(tmp);
|
||||
}
|
||||
return blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).
|
||||
xorBlocks(blocks[5]).toBytes();
|
||||
}
|
||||
};
|
||||
|
||||
/// AEGIS is a very fast authenticated encryption system built on top of the core AES function.
|
||||
///
|
||||
/// The 256 bit variant of AEGIS has a 256 bit key, a 256 bit nonce, and processes 128 bit message blocks.
|
||||
///
|
||||
/// https://competitions.cr.yp.to/round3/aegisv11.pdf
|
||||
pub const AEGIS256 = struct {
|
||||
pub const tag_length = 16;
|
||||
pub const nonce_length = 32;
|
||||
pub const key_length = 32;
|
||||
|
||||
/// c: ciphertext: output buffer should be of size m.len
|
||||
/// tag: authentication tag: output MAC
|
||||
/// m: message
|
||||
/// ad: Associated Data
|
||||
/// npub: public nonce
|
||||
/// k: private key
|
||||
pub fn encrypt(c: []u8, tag: *[tag_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) void {
|
||||
assert(c.len == m.len);
|
||||
var state = State256.init(key, npub);
|
||||
var src: [16]u8 align(16) = undefined;
|
||||
var dst: [16]u8 align(16) = undefined;
|
||||
var i: usize = 0;
|
||||
while (i + 16 <= ad.len) : (i += 16) {
|
||||
state.enc(&dst, ad[i..][0..16]);
|
||||
}
|
||||
if (ad.len % 16 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. ad.len % 16], ad[i .. i + ad.len % 16]);
|
||||
state.enc(&dst, &src);
|
||||
}
|
||||
i = 0;
|
||||
while (i + 16 <= m.len) : (i += 16) {
|
||||
state.enc(c[i..][0..16], m[i..][0..16]);
|
||||
}
|
||||
if (m.len % 16 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. m.len % 16], m[i .. i + m.len % 16]);
|
||||
state.enc(&dst, &src);
|
||||
mem.copy(u8, c[i .. i + m.len % 16], dst[0 .. m.len % 16]);
|
||||
}
|
||||
tag.* = state.mac(ad.len, m.len);
|
||||
}
|
||||
|
||||
/// m: message: output buffer should be of size c.len
|
||||
/// c: ciphertext
|
||||
/// tag: authentication tag
|
||||
/// ad: Associated Data
|
||||
/// npub: public nonce
|
||||
/// k: private key
|
||||
pub fn decrypt(m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) !void {
|
||||
assert(c.len == m.len);
|
||||
var state = State256.init(key, npub);
|
||||
var src: [16]u8 align(16) = undefined;
|
||||
var dst: [16]u8 align(16) = undefined;
|
||||
var i: usize = 0;
|
||||
while (i + 16 <= ad.len) : (i += 16) {
|
||||
state.enc(&dst, ad[i..][0..16]);
|
||||
}
|
||||
if (ad.len % 16 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. ad.len % 16], ad[i .. i + ad.len % 16]);
|
||||
state.enc(&dst, &src);
|
||||
}
|
||||
i = 0;
|
||||
while (i + 16 <= m.len) : (i += 16) {
|
||||
state.dec(m[i..][0..16], c[i..][0..16]);
|
||||
}
|
||||
if (m.len % 16 != 0) {
|
||||
mem.set(u8, src[0..], 0);
|
||||
mem.copy(u8, src[0 .. m.len % 16], c[i .. i + m.len % 16]);
|
||||
state.dec(&dst, &src);
|
||||
mem.copy(u8, m[i .. i + m.len % 16], dst[0 .. m.len % 16]);
|
||||
mem.set(u8, dst[0 .. m.len % 16], 0);
|
||||
const blocks = &state.blocks;
|
||||
blocks[0] = blocks[0].xorBlocks(AESBlock.fromBytes(&dst));
|
||||
}
|
||||
const computed_tag = state.mac(ad.len, m.len);
|
||||
var acc: u8 = 0;
|
||||
for (computed_tag) |_, j| {
|
||||
acc |= (computed_tag[j] ^ tag[j]);
|
||||
}
|
||||
if (acc != 0) {
|
||||
mem.set(u8, m, 0xaa);
|
||||
return error.AuthenticationFailed;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const htest = @import("test.zig");
|
||||
const testing = std.testing;
|
||||
|
||||
test "AEGIS128L test vector 1" {
|
||||
const key: [AEGIS128L.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 14;
|
||||
const nonce: [AEGIS128L.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 13;
|
||||
const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
||||
const m = [32]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
|
||||
var c: [m.len]u8 = undefined;
|
||||
var m2: [m.len]u8 = undefined;
|
||||
var tag: [AEGIS128L.tag_length]u8 = undefined;
|
||||
|
||||
AEGIS128L.encrypt(&c, &tag, &m, &ad, nonce, key);
|
||||
try AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key);
|
||||
testing.expectEqualSlices(u8, &m, &m2);
|
||||
|
||||
htest.assertEqual("79d94593d8c2119d7e8fd9b8fc77845c5c077a05b2528b6ac54b563aed8efe84", &c);
|
||||
htest.assertEqual("cc6f3372f6aa1bb82388d695c3962d9a", &tag);
|
||||
|
||||
c[0] +%= 1;
|
||||
testing.expectError(error.AuthenticationFailed, AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key));
|
||||
c[0] -%= 1;
|
||||
tag[0] +%= 1;
|
||||
testing.expectError(error.AuthenticationFailed, AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key));
|
||||
}
|
||||
|
||||
test "AEGIS128L test vector 2" {
|
||||
const key: [AEGIS128L.key_length]u8 = [_]u8{0x00} ** 16;
|
||||
const nonce: [AEGIS128L.nonce_length]u8 = [_]u8{0x00} ** 16;
|
||||
const ad = [_]u8{};
|
||||
const m = [_]u8{0x00} ** 16;
|
||||
var c: [m.len]u8 = undefined;
|
||||
var m2: [m.len]u8 = undefined;
|
||||
var tag: [AEGIS128L.tag_length]u8 = undefined;
|
||||
|
||||
AEGIS128L.encrypt(&c, &tag, &m, &ad, nonce, key);
|
||||
try AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key);
|
||||
testing.expectEqualSlices(u8, &m, &m2);
|
||||
|
||||
htest.assertEqual("41de9000a7b5e40e2d68bb64d99ebb19", &c);
|
||||
htest.assertEqual("f4d997cc9b94227ada4fe4165422b1c8", &tag);
|
||||
}
|
||||
|
||||
test "AEGIS128L test vector 3" {
|
||||
const key: [AEGIS128L.key_length]u8 = [_]u8{0x00} ** 16;
|
||||
const nonce: [AEGIS128L.nonce_length]u8 = [_]u8{0x00} ** 16;
|
||||
const ad = [_]u8{};
|
||||
const m = [_]u8{};
|
||||
var c: [m.len]u8 = undefined;
|
||||
var m2: [m.len]u8 = undefined;
|
||||
var tag: [AEGIS128L.tag_length]u8 = undefined;
|
||||
|
||||
AEGIS128L.encrypt(&c, &tag, &m, &ad, nonce, key);
|
||||
try AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key);
|
||||
testing.expectEqualSlices(u8, &m, &m2);
|
||||
|
||||
htest.assertEqual("83cc600dc4e3e7e62d4055826174f149", &tag);
|
||||
}
|
||||
|
||||
test "AEGIS256 test vector 1" {
|
||||
const key: [AEGIS256.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 30;
|
||||
const nonce: [AEGIS256.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 29;
|
||||
const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
||||
const m = [32]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
|
||||
var c: [m.len]u8 = undefined;
|
||||
var m2: [m.len]u8 = undefined;
|
||||
var tag: [AEGIS256.tag_length]u8 = undefined;
|
||||
|
||||
AEGIS256.encrypt(&c, &tag, &m, &ad, nonce, key);
|
||||
try AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key);
|
||||
testing.expectEqualSlices(u8, &m, &m2);
|
||||
|
||||
htest.assertEqual("f373079ed84b2709faee373584585d60accd191db310ef5d8b11833df9dec711", &c);
|
||||
htest.assertEqual("8d86f91ee606e9ff26a01b64ccbdd91d", &tag);
|
||||
|
||||
c[0] +%= 1;
|
||||
testing.expectError(error.AuthenticationFailed, AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key));
|
||||
c[0] -%= 1;
|
||||
tag[0] +%= 1;
|
||||
testing.expectError(error.AuthenticationFailed, AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key));
|
||||
}
|
||||
|
||||
test "AEGIS256 test vector 2" {
|
||||
const key: [AEGIS256.key_length]u8 = [_]u8{0x00} ** 32;
|
||||
const nonce: [AEGIS256.nonce_length]u8 = [_]u8{0x00} ** 32;
|
||||
const ad = [_]u8{};
|
||||
const m = [_]u8{0x00} ** 16;
|
||||
var c: [m.len]u8 = undefined;
|
||||
var m2: [m.len]u8 = undefined;
|
||||
var tag: [AEGIS256.tag_length]u8 = undefined;
|
||||
|
||||
AEGIS256.encrypt(&c, &tag, &m, &ad, nonce, key);
|
||||
try AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key);
|
||||
testing.expectEqualSlices(u8, &m, &m2);
|
||||
|
||||
htest.assertEqual("b98f03a947807713d75a4fff9fc277a6", &c);
|
||||
htest.assertEqual("478f3b50dc478ef7d5cf2d0f7cc13180", &tag);
|
||||
}
|
||||
|
||||
test "AEGIS256 test vector 3" {
|
||||
const key: [AEGIS256.key_length]u8 = [_]u8{0x00} ** 32;
|
||||
const nonce: [AEGIS256.nonce_length]u8 = [_]u8{0x00} ** 32;
|
||||
const ad = [_]u8{};
|
||||
const m = [_]u8{};
|
||||
var c: [m.len]u8 = undefined;
|
||||
var m2: [m.len]u8 = undefined;
|
||||
var tag: [AEGIS256.tag_length]u8 = undefined;
|
||||
|
||||
AEGIS256.encrypt(&c, &tag, &m, &ad, nonce, key);
|
||||
try AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key);
|
||||
testing.expectEqualSlices(u8, &m, &m2);
|
||||
|
||||
htest.assertEqual("f7a0878f68bd083e8065354071fc27c3", &tag);
|
||||
}
|
||||
@ -84,11 +84,21 @@ pub const Block = struct {
|
||||
};
|
||||
}
|
||||
|
||||
/// XOR the content of two blocks.
|
||||
pub inline fn xor(block1: Block, block2: Block) Block {
|
||||
/// Apply the bitwise XOR operation to the content of two blocks.
|
||||
pub inline fn xorBlocks(block1: Block, block2: Block) Block {
|
||||
return Block{ .repr = block1.repr ^ block2.repr };
|
||||
}
|
||||
|
||||
/// Apply the bitwise AND operation to the content of two blocks.
|
||||
pub inline fn andBlocks(block1: Block, block2: Block) Block {
|
||||
return Block{ .repr = block1.repr & block2.repr };
|
||||
}
|
||||
|
||||
/// Apply the bitwise OR operation to the content of two blocks.
|
||||
pub inline fn orBlocks(block1: Block, block2: Block) Block {
|
||||
return Block{ .repr = block1.repr | block2.repr };
|
||||
}
|
||||
|
||||
/// Perform operations on multiple blocks in parallel.
|
||||
pub const parallel = struct {
|
||||
/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
|
||||
@ -261,7 +271,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
|
||||
/// Encrypt a single block.
|
||||
pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
|
||||
const round_keys = ctx.key_schedule.round_keys;
|
||||
var t = Block.fromBytes(src).xor(round_keys[0]);
|
||||
var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
t = t.encrypt(round_keys[i]);
|
||||
@ -273,7 +283,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
|
||||
/// Encrypt+XOR a single block.
|
||||
pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
|
||||
const round_keys = ctx.key_schedule.round_keys;
|
||||
var t = Block.fromBytes(&counter).xor(round_keys[0]);
|
||||
var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]);
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
t = t.encrypt(round_keys[i]);
|
||||
@ -288,7 +298,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
|
||||
var ts: [count]Block = undefined;
|
||||
comptime var j = 0;
|
||||
inline while (j < count) : (j += 1) {
|
||||
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xor(round_keys[0]);
|
||||
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
|
||||
}
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
@ -310,7 +320,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
|
||||
var ts: [count]Block = undefined;
|
||||
comptime var j = 0;
|
||||
inline while (j < count) : (j += 1) {
|
||||
ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xor(round_keys[0]);
|
||||
ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
|
||||
}
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
@ -352,7 +362,7 @@ pub fn AESDecryptCtx(comptime AES: type) type {
|
||||
/// Decrypt a single block.
|
||||
pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
|
||||
const inv_round_keys = ctx.key_schedule.round_keys;
|
||||
var t = Block.fromBytes(src).xor(inv_round_keys[0]);
|
||||
var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
t = t.decrypt(inv_round_keys[i]);
|
||||
@ -367,7 +377,7 @@ pub fn AESDecryptCtx(comptime AES: type) type {
|
||||
var ts: [count]Block = undefined;
|
||||
comptime var j = 0;
|
||||
inline while (j < count) : (j += 1) {
|
||||
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xor(inv_round_keys[0]);
|
||||
ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(inv_round_keys[0]);
|
||||
}
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
|
||||
@ -125,8 +125,8 @@ pub const Block = struct {
|
||||
return Block{ .repr = BlockVec{ s0, s1, s2, s3 } };
|
||||
}
|
||||
|
||||
/// XOR the content of two blocks.
|
||||
pub inline fn xor(block1: Block, block2: Block) Block {
|
||||
/// Apply the bitwise XOR operation to the content of two blocks.
|
||||
pub inline fn xorBlocks(block1: Block, block2: Block) Block {
|
||||
var x: BlockVec = undefined;
|
||||
comptime var i = 0;
|
||||
inline while (i < 4) : (i += 1) {
|
||||
@ -135,6 +135,26 @@ pub const Block = struct {
|
||||
return Block{ .repr = x };
|
||||
}
|
||||
|
||||
/// Apply the bitwise AND operation to the content of two blocks.
|
||||
pub inline fn andBlocks(block1: Block, block2: Block) Block {
|
||||
var x: BlockVec = undefined;
|
||||
comptime var i = 0;
|
||||
inline while (i < 4) : (i += 1) {
|
||||
x[i] = block1.repr[i] & block2.repr[i];
|
||||
}
|
||||
return Block{ .repr = x };
|
||||
}
|
||||
|
||||
/// Apply the bitwise OR operation to the content of two blocks.
|
||||
pub inline fn orBlocks(block1: Block, block2: Block) Block {
|
||||
var x: BlockVec = undefined;
|
||||
comptime var i = 0;
|
||||
inline while (i < 4) : (i += 1) {
|
||||
x[i] = block1.repr[i] | block2.repr[i];
|
||||
}
|
||||
return Block{ .repr = x };
|
||||
}
|
||||
|
||||
/// Perform operations on multiple blocks in parallel.
|
||||
pub const parallel = struct {
|
||||
/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
|
||||
@ -283,7 +303,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
|
||||
/// Encrypt a single block.
|
||||
pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
|
||||
const round_keys = ctx.key_schedule.round_keys;
|
||||
var t = Block.fromBytes(src).xor(round_keys[0]);
|
||||
var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
t = t.encrypt(round_keys[i]);
|
||||
@ -295,7 +315,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
|
||||
/// Encrypt+XOR a single block.
|
||||
pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
|
||||
const round_keys = ctx.key_schedule.round_keys;
|
||||
var t = Block.fromBytes(&counter).xor(round_keys[0]);
|
||||
var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]);
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
t = t.encrypt(round_keys[i]);
|
||||
@ -349,7 +369,7 @@ pub fn AESDecryptCtx(comptime AES: type) type {
|
||||
/// Decrypt a single block.
|
||||
pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
|
||||
const inv_round_keys = ctx.key_schedule.round_keys;
|
||||
var t = Block.fromBytes(src).xor(inv_round_keys[0]);
|
||||
var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
|
||||
comptime var i = 1;
|
||||
inline while (i < rounds) : (i += 1) {
|
||||
t = t.decrypt(inv_round_keys[i]);
|
||||
|
||||
@ -149,6 +149,8 @@ const aeads = [_]Crypto{
|
||||
Crypto{ .ty = crypto.aead.ChaCha20Poly1305, .name = "chacha20Poly1305" },
|
||||
Crypto{ .ty = crypto.aead.XChaCha20Poly1305, .name = "xchacha20Poly1305" },
|
||||
Crypto{ .ty = crypto.aead.Gimli, .name = "gimli-aead" },
|
||||
Crypto{ .ty = crypto.aead.AEGIS128L, .name = "aegis-128l" },
|
||||
Crypto{ .ty = crypto.aead.AEGIS256, .name = "aegis-256" },
|
||||
};
|
||||
|
||||
pub fn benchmarkAead(comptime Aead: anytype, comptime bytes: comptime_int) !u64 {
|
||||
@ -168,7 +170,7 @@ pub fn benchmarkAead(comptime Aead: anytype, comptime bytes: comptime_int) !u64
|
||||
const start = timer.lap();
|
||||
while (offset < bytes) : (offset += in.len) {
|
||||
Aead.encrypt(in[0..], tag[0..], in[0..], &[_]u8{}, nonce, key);
|
||||
Aead.decrypt(in[0..], in[0..], tag, &[_]u8{}, nonce, key) catch unreachable;
|
||||
try Aead.decrypt(in[0..], in[0..], tag, &[_]u8{}, nonce, key);
|
||||
}
|
||||
mem.doNotOptimizeAway(&in);
|
||||
const end = timer.read();
|
||||
|
||||
@ -38,7 +38,35 @@ pub const State = struct {
|
||||
return mem.sliceAsBytes(self.data[0..]);
|
||||
}
|
||||
|
||||
pub fn permute(self: *Self) void {
|
||||
fn permute_unrolled(self: *Self) void {
|
||||
const state = &self.data;
|
||||
comptime var round = @as(u32, 24);
|
||||
inline while (round > 0) : (round -= 1) {
|
||||
var column = @as(usize, 0);
|
||||
while (column < 4) : (column += 1) {
|
||||
const x = math.rotl(u32, state[column], 24);
|
||||
const y = math.rotl(u32, state[4 + column], 9);
|
||||
const z = state[8 + column];
|
||||
state[8 + column] = ((x ^ (z << 1)) ^ ((y & z) << 2));
|
||||
state[4 + column] = ((y ^ x) ^ ((x | z) << 1));
|
||||
state[column] = ((z ^ y) ^ ((x & y) << 3));
|
||||
}
|
||||
switch (round & 3) {
|
||||
0 => {
|
||||
mem.swap(u32, &state[0], &state[1]);
|
||||
mem.swap(u32, &state[2], &state[3]);
|
||||
state[0] ^= round | 0x9e377900;
|
||||
},
|
||||
2 => {
|
||||
mem.swap(u32, &state[0], &state[2]);
|
||||
mem.swap(u32, &state[1], &state[3]);
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn permute_small(self: *Self) void {
|
||||
const state = &self.data;
|
||||
var round = @as(u32, 24);
|
||||
while (round > 0) : (round -= 1) {
|
||||
@ -66,6 +94,8 @@ pub const State = struct {
|
||||
}
|
||||
}
|
||||
|
||||
pub const permute = if (std.builtin.mode == .ReleaseSmall) permute_small else permute_unrolled;
|
||||
|
||||
pub fn squeeze(self: *Self, out: []u8) void {
|
||||
var i = @as(usize, 0);
|
||||
while (i + RATE <= out.len) : (i += RATE) {
|
||||
@ -249,15 +279,15 @@ pub const Aead = struct {
|
||||
in = in[State.RATE..];
|
||||
out = out[State.RATE..];
|
||||
}) {
|
||||
for (buf[0..State.RATE]) |*p, i| {
|
||||
p.* ^= in[i];
|
||||
out[i] = p.*;
|
||||
for (in[0..State.RATE]) |v, i| {
|
||||
buf[i] ^= v;
|
||||
}
|
||||
mem.copy(u8, out[0..State.RATE], buf[0..State.RATE]);
|
||||
state.permute();
|
||||
}
|
||||
for (buf[0..in.len]) |*p, i| {
|
||||
p.* ^= in[i];
|
||||
out[i] = p.*;
|
||||
for (in[0..]) |v, i| {
|
||||
buf[i] ^= v;
|
||||
out[i] = buf[i];
|
||||
}
|
||||
|
||||
// XOR 1 into the next byte of the state
|
||||
@ -291,15 +321,17 @@ pub const Aead = struct {
|
||||
in = in[State.RATE..];
|
||||
out = out[State.RATE..];
|
||||
}) {
|
||||
for (buf[0..State.RATE]) |*p, i| {
|
||||
out[i] = p.* ^ in[i];
|
||||
p.* = in[i];
|
||||
const d = in[0..State.RATE].*;
|
||||
for (d) |v, i| {
|
||||
out[i] = buf[i] ^ v;
|
||||
}
|
||||
mem.copy(u8, buf[0..State.RATE], d[0..State.RATE]);
|
||||
state.permute();
|
||||
}
|
||||
for (buf[0..in.len]) |*p, i| {
|
||||
out[i] = p.* ^ in[i];
|
||||
p.* = in[i];
|
||||
const d = in[i];
|
||||
out[i] = p.* ^ d;
|
||||
p.* = d;
|
||||
}
|
||||
|
||||
// XOR 1 into the next byte of the state
|
||||
|
||||
@ -95,7 +95,7 @@ test "std.event.Future" {
|
||||
// TODO provide a way to run tests in evented I/O mode
|
||||
if (!std.io.is_async) return error.SkipZigTest;
|
||||
|
||||
const handle = async testFuture();
|
||||
testFuture();
|
||||
}
|
||||
|
||||
fn testFuture() void {
|
||||
|
||||
@ -27,20 +27,24 @@ pub const Lock = struct {
|
||||
|
||||
const Waiter = struct {
|
||||
// forced Waiter alignment to ensure it doesn't clash with LOCKED
|
||||
next: ?*Waiter align(2),
|
||||
next: ?*Waiter align(2),
|
||||
tail: *Waiter,
|
||||
node: Loop.NextTickNode,
|
||||
};
|
||||
|
||||
pub fn initLocked() Lock {
|
||||
return Lock{ .head = LOCKED };
|
||||
}
|
||||
|
||||
pub fn acquire(self: *Lock) Held {
|
||||
const held = self.mutex.acquire();
|
||||
|
||||
// self.head transitions from multiple stages depending on the value:
|
||||
// UNLOCKED -> LOCKED:
|
||||
// UNLOCKED -> LOCKED:
|
||||
// acquire Lock ownership when theres no waiters
|
||||
// LOCKED -> <Waiter head ptr>:
|
||||
// Lock is already owned, enqueue first Waiter
|
||||
// <head ptr> -> <head ptr>:
|
||||
// <head ptr> -> <head ptr>:
|
||||
// Lock is owned with pending waiters. Push our waiter to the queue.
|
||||
|
||||
if (self.head == UNLOCKED) {
|
||||
@ -51,7 +55,7 @@ pub const Lock = struct {
|
||||
|
||||
var waiter: Waiter = undefined;
|
||||
waiter.next = null;
|
||||
waiter.tail = &waiter;
|
||||
waiter.tail = &waiter;
|
||||
|
||||
const head = switch (self.head) {
|
||||
UNLOCKED => unreachable,
|
||||
@ -79,15 +83,15 @@ pub const Lock = struct {
|
||||
}
|
||||
|
||||
pub const Held = struct {
|
||||
lock: *Lock,
|
||||
|
||||
lock: *Lock,
|
||||
|
||||
pub fn release(self: Held) void {
|
||||
const waiter = blk: {
|
||||
const held = self.lock.mutex.acquire();
|
||||
defer held.release();
|
||||
|
||||
// self.head goes through the reverse transition from acquire():
|
||||
// <head ptr> -> <new head ptr>:
|
||||
// <head ptr> -> <new head ptr>:
|
||||
// pop a waiter from the queue to give Lock ownership when theres still others pending
|
||||
// <head ptr> -> LOCKED:
|
||||
// pop the laster waiter from the queue, while also giving it lock ownership when awaken
|
||||
|
||||
111
lib/std/meta.zig
111
lib/std/meta.zig
@ -807,7 +807,7 @@ pub fn sizeof(target: anytype) usize {
|
||||
// TODO to get the correct result we have to translate
|
||||
// `1073741824 * 4` as `int(1073741824) *% int(4)` since
|
||||
// sizeof(1073741824 * 4) != sizeof(4294967296).
|
||||
|
||||
|
||||
// TODO test if target fits in int, long or long long
|
||||
return @sizeOf(c_int);
|
||||
},
|
||||
@ -826,3 +826,112 @@ test "sizeof" {
|
||||
testing.expect(sizeof(E.One) == @sizeOf(c_int));
|
||||
testing.expect(sizeof(S) == 4);
|
||||
}
|
||||
|
||||
/// For a given function type, returns a tuple type which fields will
|
||||
/// correspond to the argument types.
|
||||
///
|
||||
/// Examples:
|
||||
/// - `ArgsTuple(fn() void)` ⇒ `tuple { }`
|
||||
/// - `ArgsTuple(fn(a: u32) u32)` ⇒ `tuple { u32 }`
|
||||
/// - `ArgsTuple(fn(a: u32, b: f16) noreturn)` ⇒ `tuple { u32, f16 }`
|
||||
pub fn ArgsTuple(comptime Function: type) type {
|
||||
const info = @typeInfo(Function);
|
||||
if (info != .Fn)
|
||||
@compileError("ArgsTuple expects a function type");
|
||||
|
||||
const function_info = info.Fn;
|
||||
if (function_info.is_generic)
|
||||
@compileError("Cannot create ArgsTuple for generic function");
|
||||
if (function_info.is_var_args)
|
||||
@compileError("Cannot create ArgsTuple for variadic function");
|
||||
|
||||
var argument_field_list: [function_info.args.len]std.builtin.TypeInfo.StructField = undefined;
|
||||
inline for (function_info.args) |arg, i| {
|
||||
@setEvalBranchQuota(10_000);
|
||||
var num_buf: [128]u8 = undefined;
|
||||
argument_field_list[i] = std.builtin.TypeInfo.StructField{
|
||||
.name = std.fmt.bufPrint(&num_buf, "{d}", .{i}) catch unreachable,
|
||||
.field_type = arg.arg_type.?,
|
||||
.default_value = @as(?(arg.arg_type.?), null),
|
||||
.is_comptime = false,
|
||||
};
|
||||
}
|
||||
|
||||
return @Type(std.builtin.TypeInfo{
|
||||
.Struct = std.builtin.TypeInfo.Struct{
|
||||
.is_tuple = true,
|
||||
.layout = .Auto,
|
||||
.decls = &[_]std.builtin.TypeInfo.Declaration{},
|
||||
.fields = &argument_field_list,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
/// For a given anonymous list of types, returns a new tuple type
|
||||
/// with those types as fields.
|
||||
///
|
||||
/// Examples:
|
||||
/// - `Tuple(&[_]type {})` ⇒ `tuple { }`
|
||||
/// - `Tuple(&[_]type {f32})` ⇒ `tuple { f32 }`
|
||||
/// - `Tuple(&[_]type {f32,u32})` ⇒ `tuple { f32, u32 }`
|
||||
pub fn Tuple(comptime types: []const type) type {
|
||||
var tuple_fields: [types.len]std.builtin.TypeInfo.StructField = undefined;
|
||||
inline for (types) |T, i| {
|
||||
@setEvalBranchQuota(10_000);
|
||||
var num_buf: [128]u8 = undefined;
|
||||
tuple_fields[i] = std.builtin.TypeInfo.StructField{
|
||||
.name = std.fmt.bufPrint(&num_buf, "{d}", .{i}) catch unreachable,
|
||||
.field_type = T,
|
||||
.default_value = @as(?T, null),
|
||||
.is_comptime = false,
|
||||
};
|
||||
}
|
||||
|
||||
return @Type(std.builtin.TypeInfo{
|
||||
.Struct = std.builtin.TypeInfo.Struct{
|
||||
.is_tuple = true,
|
||||
.layout = .Auto,
|
||||
.decls = &[_]std.builtin.TypeInfo.Declaration{},
|
||||
.fields = &tuple_fields,
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
const TupleTester = struct {
|
||||
fn assertTypeEqual(comptime Expected: type, comptime Actual: type) void {
|
||||
if (Expected != Actual)
|
||||
@compileError("Expected type " ++ @typeName(Expected) ++ ", but got type " ++ @typeName(Actual));
|
||||
}
|
||||
|
||||
fn assertTuple(comptime expected: anytype, comptime Actual: type) void {
|
||||
const info = @typeInfo(Actual);
|
||||
if (info != .Struct)
|
||||
@compileError("Expected struct type");
|
||||
if (!info.Struct.is_tuple)
|
||||
@compileError("Struct type must be a tuple type");
|
||||
|
||||
const fields_list = std.meta.fields(Actual);
|
||||
if (expected.len != fields_list.len)
|
||||
@compileError("Argument count mismatch");
|
||||
|
||||
inline for (fields_list) |fld, i| {
|
||||
if (expected[i] != fld.field_type) {
|
||||
@compileError("Field " ++ fld.name ++ " expected to be type " ++ @typeName(expected[i]) ++ ", but was type " ++ @typeName(fld.field_type));
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
test "ArgsTuple" {
|
||||
TupleTester.assertTuple(.{}, ArgsTuple(fn () void));
|
||||
TupleTester.assertTuple(.{u32}, ArgsTuple(fn (a: u32) []const u8));
|
||||
TupleTester.assertTuple(.{ u32, f16 }, ArgsTuple(fn (a: u32, b: f16) noreturn));
|
||||
TupleTester.assertTuple(.{ u32, f16, []const u8 }, ArgsTuple(fn (a: u32, b: f16, c: []const u8) noreturn));
|
||||
}
|
||||
|
||||
test "Tuple" {
|
||||
TupleTester.assertTuple(.{}, Tuple(&[_]type{}));
|
||||
TupleTester.assertTuple(.{u32}, Tuple(&[_]type{u32}));
|
||||
TupleTester.assertTuple(.{ u32, f16 }, Tuple(&[_]type{ u32, f16 }));
|
||||
TupleTester.assertTuple(.{ u32, f16, []const u8 }, Tuple(&[_]type{ u32, f16, []const u8 }));
|
||||
}
|
||||
|
||||
@ -16715,16 +16715,12 @@ static IrInstGen *ir_analyze_bin_op_cmp_numeric(IrAnalyze *ira, IrInst *source_i
|
||||
}
|
||||
ZigType *dest_float_type = nullptr;
|
||||
uint32_t op1_bits;
|
||||
if (instr_is_comptime(op1)) {
|
||||
if (instr_is_comptime(op1) && result_type->id != ZigTypeIdVector) {
|
||||
ZigValue *op1_val = ir_resolve_const(ira, op1, UndefOk);
|
||||
if (op1_val == nullptr)
|
||||
return ira->codegen->invalid_inst_gen;
|
||||
if (op1_val->special == ConstValSpecialUndef)
|
||||
return ir_const_undef(ira, source_instr, ira->codegen->builtin_types.entry_bool);
|
||||
if (result_type->id == ZigTypeIdVector) {
|
||||
ir_add_error(ira, &op1->base, buf_sprintf("compiler bug: TODO: support comptime vector here"));
|
||||
return ira->codegen->invalid_inst_gen;
|
||||
}
|
||||
bool is_unsigned;
|
||||
if (op1_is_float) {
|
||||
BigInt bigint = {};
|
||||
@ -16750,6 +16746,7 @@ static IrInstGen *ir_analyze_bin_op_cmp_numeric(IrAnalyze *ira, IrInst *source_i
|
||||
op1_bits += 1;
|
||||
}
|
||||
} else if (op1_is_float) {
|
||||
ir_assert(op1_scalar_type->id == ZigTypeIdFloat, source_instr);
|
||||
dest_float_type = op1_scalar_type;
|
||||
} else {
|
||||
ir_assert(op1_scalar_type->id == ZigTypeIdInt, source_instr);
|
||||
@ -16759,16 +16756,12 @@ static IrInstGen *ir_analyze_bin_op_cmp_numeric(IrAnalyze *ira, IrInst *source_i
|
||||
}
|
||||
}
|
||||
uint32_t op2_bits;
|
||||
if (instr_is_comptime(op2)) {
|
||||
if (instr_is_comptime(op2) && result_type->id != ZigTypeIdVector) {
|
||||
ZigValue *op2_val = ir_resolve_const(ira, op2, UndefOk);
|
||||
if (op2_val == nullptr)
|
||||
return ira->codegen->invalid_inst_gen;
|
||||
if (op2_val->special == ConstValSpecialUndef)
|
||||
return ir_const_undef(ira, source_instr, ira->codegen->builtin_types.entry_bool);
|
||||
if (result_type->id == ZigTypeIdVector) {
|
||||
ir_add_error(ira, &op2->base, buf_sprintf("compiler bug: TODO: support comptime vector here"));
|
||||
return ira->codegen->invalid_inst_gen;
|
||||
}
|
||||
bool is_unsigned;
|
||||
if (op2_is_float) {
|
||||
BigInt bigint = {};
|
||||
@ -16794,6 +16787,7 @@ static IrInstGen *ir_analyze_bin_op_cmp_numeric(IrAnalyze *ira, IrInst *source_i
|
||||
op2_bits += 1;
|
||||
}
|
||||
} else if (op2_is_float) {
|
||||
ir_assert(op2_scalar_type->id == ZigTypeIdFloat, source_instr);
|
||||
dest_float_type = op2_scalar_type;
|
||||
} else {
|
||||
ir_assert(op2_scalar_type->id == ZigTypeIdInt, source_instr);
|
||||
@ -21934,7 +21928,17 @@ static IrInstGen *ir_analyze_instruction_elem_ptr(IrAnalyze *ira, IrInstSrcElemP
|
||||
return ira->codegen->invalid_inst_gen;
|
||||
}
|
||||
safety_check_on = false;
|
||||
} else if (array_type->id == ZigTypeIdVector) {
|
||||
uint64_t vector_len = array_type->data.vector.len;
|
||||
if (index >= vector_len) {
|
||||
ir_add_error_node(ira, elem_ptr_instruction->base.base.source_node,
|
||||
buf_sprintf("index %" ZIG_PRI_u64 " outside vector of size %" ZIG_PRI_u64,
|
||||
index, vector_len));
|
||||
return ira->codegen->invalid_inst_gen;
|
||||
}
|
||||
safety_check_on = false;
|
||||
}
|
||||
|
||||
if (array_type->id == ZigTypeIdVector) {
|
||||
ZigType *elem_type = array_type->data.vector.elem_type;
|
||||
uint32_t host_vec_len = array_type->data.vector.len;
|
||||
|
||||
@ -2,6 +2,14 @@ const tests = @import("tests.zig");
|
||||
const std = @import("std");
|
||||
|
||||
pub fn addCases(cases: *tests.CompileErrorContext) void {
|
||||
cases.add("slice sentinel mismatch",
|
||||
\\export fn entry() void {
|
||||
\\ const x = @import("std").meta.Vector(3, f32){ 25, 75, 5, 0 };
|
||||
\\}
|
||||
, &[_][]const u8{
|
||||
"tmp.zig:2:62: error: index 3 outside vector of size 3",
|
||||
});
|
||||
|
||||
cases.add("slice sentinel mismatch",
|
||||
\\export fn entry() void {
|
||||
\\ const y: [:1]const u8 = &[_:2]u8{ 1, 2 };
|
||||
@ -7548,7 +7556,7 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
|
||||
});
|
||||
|
||||
cases.add( // fixed bug #2032
|
||||
"compile diagnostic string for top level decl type",
|
||||
"compile diagnostic string for top level decl type",
|
||||
\\export fn entry() void {
|
||||
\\ var foo: u32 = @This(){};
|
||||
\\}
|
||||
|
||||
@ -274,6 +274,14 @@ test "vector comparison operators" {
|
||||
expectEqual(@splat(4, true), v1 != v3);
|
||||
expectEqual(@splat(4, false), v1 != v2);
|
||||
}
|
||||
{
|
||||
// Comptime-known LHS/RHS
|
||||
var v1: @Vector(4, u32) = [_]u32{ 2, 1, 2, 1 };
|
||||
const v2 = @splat(4, @as(u32, 2));
|
||||
const v3: @Vector(4, bool) = [_]bool{ true, false, true, false };
|
||||
expectEqual(v3, v1 == v2);
|
||||
expectEqual(v3, v2 == v1);
|
||||
}
|
||||
}
|
||||
};
|
||||
S.doTheTest();
|
||||
|
||||
Loading…
Reference in New Issue
Block a user