Merge pull request #116 from permaweb/fix/httpsig-names-from-dict

fix: extract httpsig signature names from signature fields

src/dev_codec_httpsig.erl

@@ -175,28 +175,32 @@ reset_hmac(RawMsg) ->
     AllSigs =
         maps:from_list(lists:map(
             fun ({Attestor, #{ <<"signature">> := Signature }}) ->
-                SigName = address_to_sig_name(Attestor),
+                SigNameFromDict = sig_name_from_dict(Signature),
+                ?event({name_options,
+                    {attestor, Attestor},
+                    {sig_name_from_dict, SigNameFromDict}}
+                ),
                 SigBin =
-                    maps:get(SigName,
+                    maps:get(SigNameFromDict,
                         maps:from_list(
                             dev_codec_structured_conv:parse_dictionary(Signature)
                         )
                     ),
-                ?event({SigName, SigBin}),
-                {SigName, SigBin}
+                ?event({SigNameFromDict, SigBin}),
+                {SigNameFromDict, SigBin}
             end,
             maps:to_list(Attestations)
         )),
     AllInputs =
         maps:from_list(lists:map(
-            fun ({Attestor, #{ <<"signature-input">> := Inputs }}) ->
-                SigName = address_to_sig_name(Attestor),
+            fun ({_Attestor, #{ <<"signature-input">> := Inputs }}) ->
+                SigNameFromDict = sig_name_from_dict(Inputs),
                 ?event({trying_to_parse, Inputs}),
                 Res = dev_codec_structured_conv:parse_dictionary(Inputs),
                 ?event({parsed_dict, Res}),
-                SingleSigInput = maps:get(SigName, maps:from_list(Res)),
+                SingleSigInput = maps:get(SigNameFromDict, maps:from_list(Res)),
                 ?event({single_sig_input, SingleSigInput}),
-                {SigName, SingleSigInput}
+                {SigNameFromDict, SingleSigInput}
             end,
             maps:to_list(Attestations)
         )),
@@ -225,6 +229,10 @@ reset_hmac(RawMsg) ->
     ?event({reset_hmac_complete, {explicit, Res}}),
     Res.
 
+sig_name_from_dict(DictBin) ->
+    [{SigNameFromDict, _}] = dev_codec_structured_conv:parse_dictionary(DictBin),
+    SigNameFromDict.
+
 %% @doc Generate the ID of the message, with the current signature and signature
 %% input as the components for the hmac.
 hmac(Msg) ->

src/dev_meta.erl

@@ -48,7 +48,7 @@ handle_initialize([], _NodeMsg) ->
 info(_, Request, NodeMsg) ->
     case hb_converge:get(<<"method">>, Request, NodeMsg) of
         <<"GET">> ->
-            ?event(debug, {get_config_req, Request, NodeMsg}),
+            ?event({get_config_req, Request, NodeMsg}),
             embed_status({ok, hb_private:reset(NodeMsg)});
         <<"POST">> ->
             case hb_converge:get(<<"initialized">>, NodeMsg, not_found, NodeMsg) of
@@ -85,10 +85,10 @@ update_node_message(Request, NodeMsg) ->
         end,
     case EncOperator == unclaimed orelse lists:member(EncOperator, RequestSigners) of
         false ->
-            ?event(debug, {set_node_message_fail, Request}),
+            ?event({set_node_message_fail, Request}),
             embed_status({error, <<"Unauthorized">>});
         true ->
-            ?event(debug, {set_node_message_success, Request}),
+            ?event({set_node_message_success, Request}),
             hb_http_server:set_opts(
                 Request#{
                     http_server =>

src/dev_snp.erl

@@ -37,15 +37,15 @@ real_node_test() ->
                     <<"is-trusted-device">> => <<"[email protected]">>
                 }
             ),
-        ?event(debug, {snp_report_rcvd, Report}),
-        ?event(debug, {report_verifies, hb_message:verify(Report)}),
+        ?event({snp_report_rcvd, Report}),
+        ?event({report_verifies, hb_message:verify(Report)}),
         Result =
             verify(
                 Report,
                 #{ <<"target">> => <<"self">> },
                 #{ trusted => ?TEST_TRUSTED_SOFTWARE }
             ),
-        ?event(debug, {snp_validation_res, Result}),
+        ?event({snp_validation_res, Result}),
         ?assertEqual({ok, true}, Result)
     end.
 
@@ -176,8 +176,8 @@ generate(_M1, _M2, Opts) ->
                 Opts
             ),
 	RawPublicNodeMsgID = hb_util:native_id(PublicNodeMsgID),
-	?event(debug, {snp_node_msg, NodeMsg}),
-    ?event(debug, {snp_node_msg_id, byte_size(RawPublicNodeMsgID)}),
+	?event({snp_node_msg, NodeMsg}),
+    ?event({snp_node_msg_id, byte_size(RawPublicNodeMsgID)}),
     % Generate the attestation report.
 	?event({snp_address,  byte_size(Address)}),
     ReportData = generate_nonce(Address, RawPublicNodeMsgID),
@@ -217,7 +217,7 @@ execute_is_trusted(M1, Msg, NodeOpts) ->
             not_found -> M1#{ <<"device">> => <<"[email protected]">> };
             Device -> {as, Device, M1}
         end,
-    %?event(debug, {starting_to_validate_software, {mod_m1, {explicit, ModM1}}, {m2, {explicit, Msg}}, {node_opts, {explicit, NodeOpts}}}),
+    %?event({starting_to_validate_software, {mod_m1, {explicit, ModM1}}, {m2, {explicit, Msg}}, {node_opts, {explicit, NodeOpts}}}),
     Result = lists:all(
         fun(ReportKey) ->
             ReportVal = hb_converge:get(ReportKey, Msg, NodeOpts),
@@ -252,14 +252,14 @@ trusted(_Msg1, Msg2, NodeOpts) ->
     %% Ensure Trusted is always a map
     TrustedSoftware = hb_opts:get(trusted, #{}, NodeOpts),
     PropertyName = hb_converge:get(Key, TrustedSoftware, not_found, NodeOpts),
-    ?event(debug, {trust_key, PropertyName, maps:is_key(Key, TrustedSoftware)}),
+    ?event({trust_key, PropertyName, maps:is_key(Key, TrustedSoftware)}),
     %% Final trust validation
     {ok, PropertyName == Body}.
 
 %% @doc Ensure that the report data matches the expected report data.
 report_data_matches(Address, NodeMsgID, ReportData) ->
-	?event(debug, {generated_nonce, binary_to_list(generate_nonce(Address, NodeMsgID))}),
-	?event(debug, {expected_nonce, binary_to_list(ReportData)}),
+	?event({generated_nonce, binary_to_list(generate_nonce(Address, NodeMsgID))}),
+	?event({expected_nonce, binary_to_list(ReportData)}),
     generate_nonce(Address, NodeMsgID) == ReportData.
 
 %% @doc Generate the nonce to use in the attestation report.