跳转到内容

std.crypto.codecs.asn1.der.Encoder

标准库Zig 0.17.1官方原文
源码std/crypto/codecs/asn1/der/Encoder.zig

第 1 行

带缓冲的 DER 编码器。

优先调用容器的 fn encodeDer(self: @This(), encoder: *der.Encoder)。 该函数应依次编码值、长度,再编码标签。

字段

buffer: ArrayListReverse
field_tag: ?FieldTag = null

父容器设置的字段标签。 这是必要的,因为可能访问具有 fn encodeDer 的隐式标记容器。

std.crypto.codecs.asn1.der.Encoder.any

函数

第 19 行

编码任意值。

pub fn any(self: *Encoder, val: anytype) !void

参数

self: *Encoder

用法示例

test any {
    const Enum = enum(u8) {
        x = 0,
    };

    try checkAnyEncoding(u16, 0, &.{ 0x02, 0x01, 0x00 });
    try checkAnyEncoding(Enum, .x, &.{ 0x0a, 0x01, 0x00 });
}

std.crypto.codecs.asn1.der.Encoder.anyTag

函数

第 44 行

fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void

参数

self: *Encoder
tag_: Tag

std.crypto.codecs.asn1.der.Encoder.ArrayListReverse

别名

第 248 行

别名目标 std.crypto.codecs.asn1.der.ArrayListReverse

std.crypto.codecs.asn1.der.Encoder.asn1

别名

第 247 行

别名目标 std.crypto.codecs.asn1

std.crypto.codecs.asn1.der.Encoder.checkAnyEncoding

函数

第 33 行

fn checkAnyEncoding(T: type, value: T, expected: []const u8) !void

参数

T: type
value: T
expected: []const u8

std.crypto.codecs.asn1.der.Encoder.deinit

函数

第 14 行

pub fn deinit(self: *Encoder) void

参数

self: *Encoder

std.crypto.codecs.asn1.der.Encoder.Encoder

别名

第 251 行

别名目标 std.crypto.codecs.asn1.der.Encoder

std.crypto.codecs.asn1.der.Encoder.FieldTag

别名

第 250 行

别名目标 std.crypto.codecs.asn1.FieldTag

std.crypto.codecs.asn1.der.Encoder.init

函数

第 10 行

pub fn init(allocator: std.mem.Allocator) Encoder

参数

allocator: std.mem.Allocator

std.crypto.codecs.asn1.der.Encoder.int

函数

第 146 行

fn int(self: *Encoder, comptime T: type, value: T) !void

参数

self: *Encoder
T: type
value: T

用法示例

test int {
    const allocator = std.testing.allocator;
    var encoder = Encoder.init(allocator);
    defer encoder.deinit();

    try encoder.int(u8, 0);
    try std.testing.expectEqualSlices(u8, &.{0}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 0x00ff);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u32, 0xffff);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0xff, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u32, 0x01020304);
    try std.testing.expectEqualSlices(u8, &.{ 0x01, 0x02, 0x03, 0x04 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u8, 127);
    try std.testing.expectEqualSlices(u8, &.{0x7f}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 128);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0x80 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 256);
    try std.testing.expectEqualSlices(u8, &.{ 0x01, 0x00 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u8, 128);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0x80 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u8, 255);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 0x8000);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0x80, 0 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(i8, -1);
    try std.testing.expectEqualSlices(u8, &.{0xff}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(i8, -128);
    try std.testing.expectEqualSlices(u8, &.{0x80}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(i16, -129);
    try std.testing.expectEqualSlices(u8, &.{ 0xff, 0x7f }, encoder.buffer.data);
}

std.crypto.codecs.asn1.der.Encoder.length

函数

第 122 行

编码长度。

pub fn length(self: *Encoder, len: usize) !void

参数

self: *Encoder
len: usize

用法示例

test length {
    const allocator = std.testing.allocator;
    var encoder = Encoder.init(allocator);
    defer encoder.deinit();

    try encoder.length(127);
    try std.testing.expectEqualSlices(u8, &.{0x7f}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(128);
    try std.testing.expectEqualSlices(u8, &.{ 0x81, 0x80 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(255);
    try std.testing.expectEqualSlices(u8, &.{ 0x81, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(256);
    try std.testing.expectEqualSlices(u8, &.{ 0x82, 0x01, 0x00 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(65535);
    try std.testing.expectEqualSlices(u8, &.{ 0x82, 0xff, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(65536);
    try std.testing.expectEqualSlices(u8, &.{ 0x83, 0x01, 0x00, 0x00 }, encoder.buffer.data);
}

std.crypto.codecs.asn1.der.Encoder.mergedTag

函数

第 110 行

fn mergedTag(self: *Encoder, tag_: Tag) Tag

参数

self: *Encoder
tag_: Tag

std.crypto.codecs.asn1.der.Encoder.Oid

别名

第 246 行

别名目标 std.crypto.codecs.asn1.Oid

std.crypto.codecs.asn1.der.Encoder.prependBytes

函数

第 142 行

写入原始字节。编码器从后向前构造输出, 因此连续调用应采用与所需线上顺序相反的顺序。

pub fn prependBytes(self: *Encoder, bytes: []const u8) !void

参数

self: *Encoder
bytes: []const u8

std.crypto.codecs.asn1.der.Encoder.std

别名

第 245 行

别名目标 std

std.crypto.codecs.asn1.der.Encoder.tag

函数

第 104 行

编码标签。

pub fn tag(self: *Encoder, tag_: Tag) !void

参数

self: *Encoder
tag_: Tag

std.crypto.codecs.asn1.der.Encoder.Tag

别名

第 249 行

别名目标 std.crypto.codecs.asn1.Tag

std.crypto.codecs.asn1.der.Encoder.tagBytes

函数

第 134 行

编码标签和带长度前缀的字节。

pub fn tagBytes(self: *Encoder, tag_: Tag, bytes: []const u8) !void

参数

self: *Encoder
tag_: Tag
bytes: []const u8
源码

std/crypto/codecs/asn1/der/Encoder.zig

//! 带缓冲的 DER 编码器。
//!
//! 优先调用容器的 `fn encodeDer(self: @This(), encoder: *der.Encoder)`。
//! 该函数应依次编码值、长度,再编码标签。
buffer: ArrayListReverse,
/// 父容器设置的字段标签。
/// 这是必要的,因为可能访问具有 `fn encodeDer` 的隐式标记容器。
field_tag: ?FieldTag = null,

pub fn init(allocator: std.mem.Allocator) Encoder {
    return Encoder{ .buffer = ArrayListReverse.init(allocator) };
}

pub fn deinit(self: *Encoder) void {
    self.buffer.deinit();
}

/// 编码任意值。
pub fn any(self: *Encoder, val: anytype) !void {
    const T = @TypeOf(val);
    try self.anyTag(Tag.fromZig(T), val);
}

test any {
    const Enum = enum(u8) {
        x = 0,
    };

    try checkAnyEncoding(u16, 0, &.{ 0x02, 0x01, 0x00 });
    try checkAnyEncoding(Enum, .x, &.{ 0x0a, 0x01, 0x00 });
}

fn checkAnyEncoding(T: type, value: T, expected: []const u8) !void {
    var encoder: @This() = .init(std.testing.allocator);
    defer encoder.deinit();

    try encoder.any(value);
    const encoded = try encoder.buffer.toOwnedSlice();
    defer std.testing.allocator.free(encoded);

    try std.testing.expectEqualSlices(u8, expected, encoded);
}

fn anyTag(self: *Encoder, tag_: Tag, val: anytype) !void {
    const T = @TypeOf(val);
    if (std.meta.hasFn(T, "encodeDer")) return try val.encodeDer(self);
    const outer_field_tag = self.field_tag;
    const start = self.buffer.data.len;
    const merged_tag = self.mergedTag(tag_);

    switch (@typeInfo(T)) {
        .@"struct" => |info| {
            inline for (0..info.field_names.len) |i| {
                const f_idx = info.field_names.len - i - 1;
                const f_name = info.field_names[f_idx];
                const f_type = info.field_types[f_idx];
                const f_attrs = info.field_attrs[f_idx];
                const field_val = @field(val, f_name);
                const field_tag = FieldTag.fromContainer(T, f_name);

                // 集合值或序列值的编码,不得包含任何与其默认值相等的
                // 分量值的编码。
                const is_default = if (f_attrs.@"comptime") false else if (f_attrs.defaultValue(f_type)) |default_val| brk: {
                    break :brk std.mem.eql(u8, std.mem.asBytes(&default_val), std.mem.asBytes(&field_val));
                } else false;
                const is_null_optional = if (@typeInfo(f_type) == .optional) field_val == null else false;

                if (!is_default and !is_null_optional) {
                    const start2 = self.buffer.data.len;
                    self.field_tag = field_tag;
                    // 将与 self.field_tag 合并。
                    // 可能修改 self.field_tag。
                    try self.anyTag(Tag.fromZig(f_type), field_val);
                    if (field_tag) |ft| {
                        if (ft.explicit) {
                            try self.length(self.buffer.data.len - start2);
                            try self.tag(ft.toTag());
                            self.field_tag = null;
                        }
                    }
                }
            }
            self.field_tag = outer_field_tag;
        },
        .bool => try self.buffer.prependSlice(&[_]u8{if (val) 0xff else 0}),
        .int => try self.int(T, val),
        .@"enum" => |e| {
            if (@hasDecl(T, "oids")) {
                return self.any(T.oids.enumToOid(val));
            } else {
                try self.int(e.tag_type, @backingInt(val));
            }
        },
        .optional => if (val) |v| return try self.anyTag(tag_, v) else return,
        .null => {},
        else => @compileError("cannot encode type " ++ @typeName(T)),
    }

    try self.length(self.buffer.data.len - start);
    try self.tag(merged_tag);
}

/// 编码标签。
pub fn tag(self: *Encoder, tag_: Tag) !void {
    const t = self.mergedTag(tag_);
    var buf: [Tag.max_encoded_len]u8 = undefined;
    try self.buffer.prependSlice(t.encodeToSlice(&buf));
}

fn mergedTag(self: *Encoder, tag_: Tag) Tag {
    var res = tag_;
    if (self.field_tag) |ft| {
        if (!ft.explicit) {
            res.number = @fromBackingInt(@intCast(ft.number));
            res.class = ft.class;
        }
    }
    return res;
}

/// 编码长度。
pub fn length(self: *Encoder, len: usize) !void {
    if (len < 128) return self.buffer.prependSlice(&.{@intCast(len)});
    const len32 = std.math.cast(u32, len) orelse return error.InvalidLength;
    var buf: [@sizeOf(u32) + 1]u8 = undefined;
    std.mem.writeInt(u32, buf[1..], len32, .big);
    var first: usize = 1;
    while (buf[first] == 0) first += 1;
    buf[first - 1] = @intCast((buf.len - first) | 0x80);
    return self.buffer.prependSlice(buf[first - 1 ..]);
}

/// 编码标签和带长度前缀的字节。
pub fn tagBytes(self: *Encoder, tag_: Tag, bytes: []const u8) !void {
    try self.buffer.prependSlice(bytes);
    try self.length(bytes.len);
    try self.tag(tag_);
}

/// 写入原始字节。编码器从后向前构造输出,
/// 因此连续调用应采用与所需线上顺序相反的顺序。
pub fn prependBytes(self: *Encoder, bytes: []const u8) !void {
    return self.buffer.prependSlice(bytes);
}

fn int(self: *Encoder, comptime T: type, value: T) !void {
    const info = @typeInfo(T).int;
    const Unsigned = @Int(.unsigned, info.bits);
    const pad: u8 = if (info.signedness == .signed and value < 0) 0xff else 0;
    var buf: [@sizeOf(Unsigned) + 1]u8 = undefined;
    buf[0] = pad;
    std.mem.writeInt(Unsigned, buf[1..], @bitCast(value), .big);

    var first: usize = 0;
    while (first + 1 < buf.len and buf[first] == pad and (buf[first + 1] ^ pad) & 0x80 == 0) first += 1;
    try self.buffer.prependSlice(buf[first..]);
}

test int {
    const allocator = std.testing.allocator;
    var encoder = Encoder.init(allocator);
    defer encoder.deinit();

    try encoder.int(u8, 0);
    try std.testing.expectEqualSlices(u8, &.{0}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 0x00ff);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u32, 0xffff);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0xff, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u32, 0x01020304);
    try std.testing.expectEqualSlices(u8, &.{ 0x01, 0x02, 0x03, 0x04 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u8, 127);
    try std.testing.expectEqualSlices(u8, &.{0x7f}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 128);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0x80 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 256);
    try std.testing.expectEqualSlices(u8, &.{ 0x01, 0x00 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u8, 128);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0x80 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u8, 255);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(u16, 0x8000);
    try std.testing.expectEqualSlices(u8, &.{ 0, 0x80, 0 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(i8, -1);
    try std.testing.expectEqualSlices(u8, &.{0xff}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(i8, -128);
    try std.testing.expectEqualSlices(u8, &.{0x80}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.int(i16, -129);
    try std.testing.expectEqualSlices(u8, &.{ 0xff, 0x7f }, encoder.buffer.data);
}

test length {
    const allocator = std.testing.allocator;
    var encoder = Encoder.init(allocator);
    defer encoder.deinit();

    try encoder.length(127);
    try std.testing.expectEqualSlices(u8, &.{0x7f}, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(128);
    try std.testing.expectEqualSlices(u8, &.{ 0x81, 0x80 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(255);
    try std.testing.expectEqualSlices(u8, &.{ 0x81, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(256);
    try std.testing.expectEqualSlices(u8, &.{ 0x82, 0x01, 0x00 }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(65535);
    try std.testing.expectEqualSlices(u8, &.{ 0x82, 0xff, 0xff }, encoder.buffer.data);

    encoder.buffer.clearAndFree();
    try encoder.length(65536);
    try std.testing.expectEqualSlices(u8, &.{ 0x83, 0x01, 0x00, 0x00 }, encoder.buffer.data);
}

const std = @import("std");
const Oid = @import("../Oid.zig");
const asn1 = @import("../../asn1.zig");
const ArrayListReverse = @import("./ArrayListReverse.zig");
const Tag = asn1.Tag;
const FieldTag = asn1.FieldTag;
const Encoder = @This();