kryptos

-module(kryptos@internal@der).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/kryptos/internal/der.gleam").
-export([parse_length/1, encode_length/1, encode_sequence/1, parse_sequence/1, parse_integer/1, encode_integer/1]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-file("src/kryptos/internal/der.gleam", 14).
?DOC(false).
-spec parse_length(bitstring()) -> {ok, {integer(), bitstring()}} | {error, nil}.
parse_length(Bytes) ->
    case Bytes of
        <<Len:8, Rest/bitstring>> when Len < 128 ->
            {ok, {Len, Rest}};

        <<16#81, Len@1:8, Rest@1/bitstring>> when Len@1 >= 128 ->
            {ok, {Len@1, Rest@1}};

        <<16#82, Len@2:16, Rest@2/bitstring>> when Len@2 >= 256 ->
            {ok, {Len@2, Rest@2}};

        _ ->
            {error, nil}
    end.

-file("src/kryptos/internal/der.gleam", 24).
?DOC(false).
-spec encode_length(integer()) -> bitstring().
encode_length(Len) ->
    case Len of
        L when L < 128 ->
            <<L:8>>;

        L@1 when L@1 < 256 ->
            <<16#81, L@1:8>>;

        L@2 ->
            <<16#82, L@2:16>>
    end.

-file("src/kryptos/internal/der.gleam", 92).
?DOC(false).
-spec require_tag(
    bitstring(),
    integer(),
    fun((bitstring()) -> {ok, UEU} | {error, nil})
) -> {ok, UEU} | {error, nil}.
require_tag(Bytes, Tag, Next) ->
    case Bytes of
        <<T:8, Rest/bitstring>> when T =:= Tag ->
            Next(Rest);

        _ ->
            {error, nil}
    end.

-file("src/kryptos/internal/der.gleam", 103).
?DOC(false).
-spec reject_non_minimal_zeros(bitstring(), fun(() -> {ok, UEZ} | {error, nil})) -> {ok,
        UEZ} |
    {error, nil}.
reject_non_minimal_zeros(Value, Next) ->
    case Value of
        <<16#00, Second:8, _/bitstring>> when Second < 128 ->
            {error, nil};

        _ ->
            Next()
    end.

-file("src/kryptos/internal/der.gleam", 71).
?DOC(false).
-spec encode_sequence(bitstring()) -> bitstring().
encode_sequence(Content) ->
    gleam_stdlib:bit_array_concat(
        [<<16#30>>, encode_length(erlang:byte_size(Content)), Content]
    ).

-file("src/kryptos/internal/der.gleam", 80).
?DOC(false).
-spec parse_sequence(bitstring()) -> {ok, {bitstring(), bitstring()}} |
    {error, nil}.
parse_sequence(Bytes) ->
    require_tag(
        Bytes,
        16#30,
        fun(Rest) ->
            gleam@result:'try'(
                parse_length(Rest),
                fun(_use0) ->
                    {Len, Content} = _use0,
                    Content_size = erlang:byte_size(Content),
                    gleam@bool:guard(
                        Content_size < Len,
                        {error, nil},
                        fun() ->
                            Inner@1 = case gleam_stdlib:bit_array_slice(
                                Content,
                                0,
                                Len
                            ) of
                                {ok, Inner} -> Inner;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"kryptos/internal/der"/utf8>>,
                                                function => <<"parse_sequence"/utf8>>,
                                                line => 87,
                                                value => _assert_fail,
                                                start => 2727,
                                                'end' => 2782,
                                                pattern_start => 2738,
                                                pattern_end => 2747})
                            end,
                            Remaining@1 = case gleam_stdlib:bit_array_slice(
                                Content,
                                Len,
                                Content_size - Len
                            ) of
                                {ok, Remaining} -> Remaining;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"kryptos/internal/der"/utf8>>,
                                                function => <<"parse_sequence"/utf8>>,
                                                line => 88,
                                                value => _assert_fail@1,
                                                start => 2785,
                                                'end' => 2861,
                                                pattern_start => 2796,
                                                pattern_end => 2809})
                            end,
                            {ok, {Inner@1, Remaining@1}}
                        end
                    )
                end
            )
        end
    ).

-file("src/kryptos/internal/der.gleam", 36).
?DOC(false).
-spec parse_integer(bitstring()) -> {ok, {bitstring(), bitstring()}} |
    {error, nil}.
parse_integer(Bytes) ->
    require_tag(
        Bytes,
        16#02,
        fun(Rest) ->
            gleam@result:'try'(
                parse_length(Rest),
                fun(_use0) ->
                    {Len, Content} = _use0,
                    gleam@bool:guard(
                        Len =< 0,
                        {error, nil},
                        fun() ->
                            Content_size = erlang:byte_size(Content),
                            gleam@bool:guard(
                                Content_size < Len,
                                {error, nil},
                                fun() ->
                                    Value@1 = case gleam_stdlib:bit_array_slice(
                                        Content,
                                        0,
                                        Len
                                    ) of
                                        {ok, Value} -> Value;
                                        _assert_fail ->
                                            erlang:error(
                                                    #{gleam_error => let_assert,
                                                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                        file => <<?FILEPATH/utf8>>,
                                                        module => <<"kryptos/internal/der"/utf8>>,
                                                        function => <<"parse_integer"/utf8>>,
                                                        line => 44,
                                                        value => _assert_fail,
                                                        start => 1429,
                                                        'end' => 1484,
                                                        pattern_start => 1440,
                                                        pattern_end => 1449}
                                                )
                                    end,
                                    reject_non_minimal_zeros(
                                        Value@1,
                                        fun() ->
                                            Remaining@1 = case gleam_stdlib:bit_array_slice(
                                                Content,
                                                Len,
                                                Content_size - Len
                                            ) of
                                                {ok, Remaining} -> Remaining;
                                                _assert_fail@1 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"kryptos/internal/der"/utf8>>,
                                                                function => <<"parse_integer"/utf8>>,
                                                                line => 47,
                                                                value => _assert_fail@1,
                                                                start => 1529,
                                                                'end' => 1605,
                                                                pattern_start => 1540,
                                                                pattern_end => 1553}
                                                        )
                                            end,
                                            {ok, {Value@1, Remaining@1}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/kryptos/internal/der.gleam", 54).
?DOC(false).
-spec encode_integer(bitstring()) -> bitstring().
encode_integer(Value) ->
    Stripped = kryptos@internal@utils:strip_leading_zeros(Value),
    Int_bytes = case Stripped of
        <<High:8, _/bitstring>> when High >= 128 ->
            gleam_stdlib:bit_array_concat([<<16#00>>, Stripped]);

        <<>> ->
            <<16#00>>;

        _ ->
            Stripped
    end,
    gleam_stdlib:bit_array_concat(
        [<<16#02>>, encode_length(erlang:byte_size(Int_bytes)), Int_bytes]
    ).