#include #include #include #include #include #include #include struct onion_message_hook_payload { /* Optional */ struct pubkey *blinding_in; struct pubkey *reply_blinding; struct onionmsg_path **reply_path; struct tlv_onionmsg_payload *om; }; static void onion_message_serialize(struct onion_message_hook_payload *payload, struct json_stream *stream, struct plugin *plugin) { json_object_start(stream, "onion_message"); if (payload->blinding_in) json_add_pubkey(stream, "blinding_in", payload->blinding_in); if (payload->reply_path) { json_array_start(stream, "reply_path"); for (size_t i = 0; i < tal_count(payload->reply_path); i++) { json_object_start(stream, NULL); json_add_pubkey(stream, "id", &payload->reply_path[i]->node_id); if (payload->reply_path[i]->enctlv) json_add_hex_talarr(stream, "enctlv", payload->reply_path[i]->enctlv); if (i == 0) json_add_pubkey(stream, "blinding", payload->reply_blinding); json_object_end(stream); } json_array_end(stream); } /* Common convenience fields */ if (payload->om->invoice_request) json_add_hex_talarr(stream, "invoice_request", payload->om->invoice_request); if (payload->om->invoice) json_add_hex_talarr(stream, "invoice", payload->om->invoice); if (payload->om->invoice_error) json_add_hex_talarr(stream, "invoice_error", payload->om->invoice_error); json_array_start(stream, "unknown_fields"); for (size_t i = 0; i < tal_count(payload->om->fields); i++) { if (payload->om->fields[i].meta) continue; json_object_start(stream, NULL); json_add_u64(stream, "number", payload->om->fields[i].numtype); json_add_hex(stream, "value", payload->om->fields[i].value, payload->om->fields[i].length); json_object_end(stream); } json_array_end(stream); json_object_end(stream); } static void onion_message_hook_cb(struct onion_message_hook_payload *payload STEALS) { /* plugin_hook_continue checks the "result"; anything other than continue * just stops. */ tal_free(payload); } /* Two hooks, because it's critical we only accept blinding if we expect that * exact blinding key. Otherwise, we can be probed using old blinded paths. */ REGISTER_PLUGIN_HOOK(onion_message, plugin_hook_continue, onion_message_hook_cb, onion_message_serialize, struct onion_message_hook_payload *); REGISTER_PLUGIN_HOOK(onion_message_blinded, plugin_hook_continue, onion_message_hook_cb, onion_message_serialize, struct onion_message_hook_payload *); void handle_onionmsg_to_us(struct lightningd *ld, const u8 *msg) { struct onion_message_hook_payload *payload; u8 *submsg; size_t submsglen; const u8 *subptr; payload = tal(ld, struct onion_message_hook_payload); payload->om = tlv_onionmsg_payload_new(payload); if (!fromwire_gossipd_got_onionmsg_to_us(payload, msg, &payload->blinding_in, &payload->reply_blinding, &payload->reply_path, &submsg)) { log_broken(ld->log, "bad got_onionmsg_tous: %s", tal_hex(tmpctx, msg)); return; } submsglen = tal_bytelen(submsg); subptr = submsg; if (!fromwire_onionmsg_payload(&subptr, &submsglen, payload->om)) { tal_free(payload); log_broken(ld->log, "bad got_onionmsg_tous om: %s", tal_hex(tmpctx, msg)); return; } tal_free(submsg); if (payload->reply_path && !payload->reply_blinding) { log_broken(ld->log, "No reply blinding, ignoring reply path"); payload->reply_path = tal_free(payload->reply_path); } log_debug(ld->log, "Got onionmsg%s%s", payload->reply_blinding ? " reply_blinding": "", payload->reply_path ? " reply_path": ""); if (payload->blinding_in) plugin_hook_call_onion_message_blinded(ld, payload); else plugin_hook_call_onion_message(ld, payload); } void handle_onionmsg_forward(struct lightningd *ld, const u8 *msg) { struct short_channel_id *next_scid; struct node_id *next_node; struct pubkey *next_blinding; u8 *onion; if (!fromwire_gossipd_got_onionmsg_forward(msg, msg, &next_scid, &next_node, &next_blinding, &onion)) { log_broken(ld->log, "bad got_onionmsg_forward: %s", tal_hex(tmpctx, msg)); return; } if (next_scid) { struct channel *outchan = any_channel_by_scid(ld, next_scid); if (outchan) next_node = &outchan->peer->id; } if (!next_node) { log_debug(ld->log, "Cannot forward onionmsg to %s", next_scid ? type_to_string(tmpctx, struct short_channel_id, next_scid) : "unspecified dest"); } else { subd_send_msg(ld->gossip, take(towire_gossipd_send_onionmsg(NULL, next_node, onion, next_blinding))); } } struct hop { struct pubkey id; struct short_channel_id *scid; struct pubkey *blinding; u8 *enctlv; u8 *invoice; u8 *invoice_req; u8 *invoice_err; u8 *rawtlv; }; static struct command_result *param_hops(struct command *cmd, const char *name, const char *buffer, const jsmntok_t *tok, struct hop **hops) { size_t i; const jsmntok_t *t; if (tok->type != JSMN_ARRAY || tok->size == 0) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s must be an (non-empty) array", name); *hops = tal_arr(cmd, struct hop, tok->size); json_for_each_arr(i, t, tok) { const jsmntok_t *tid, *tscid, *tblinding, *tenctlv, *trawtlv, *tinvoice, *tinvoicereq, *tinvoiceerr; tid = json_get_member(buffer, t, "id"); if (!tid) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] does not have 'id'", name, i); tscid = json_get_member(buffer, t, "short_channel_id"); tblinding = json_get_member(buffer, t, "blinding"); tenctlv = json_get_member(buffer, t, "enctlv"); tinvoice = json_get_member(buffer, t, "invoice"); tinvoicereq = json_get_member(buffer, t, "invoice_request"); tinvoiceerr = json_get_member(buffer, t, "invoice_error"); trawtlv = json_get_member(buffer, t, "rawtlv"); if (trawtlv && (tscid || tblinding || tenctlv || tinvoice || tinvoicereq)) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] has 'rawtlv' with other fields", name, i); if (tblinding) { (*hops)[i].blinding = tal(*hops, struct pubkey); if (!json_to_pubkey(buffer, tblinding, (*hops)[i].blinding)) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'blinding' is invalid", name, i); } else (*hops)[i].blinding = NULL; if (!json_to_pubkey(buffer, tid, &(*hops)[i].id)) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'id' is invalid", name, i); if (tscid) { (*hops)[i].scid = tal(*hops, struct short_channel_id); if (!json_to_short_channel_id(buffer, tscid, (*hops)[i].scid)) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'short_channel_id' is invalid", name, i); } else (*hops)[i].scid = NULL; if (tenctlv) { (*hops)[i].enctlv = json_tok_bin_from_hex(*hops, buffer, tenctlv); if (!(*hops)[i].enctlv) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'enctlv' is invalid", name, i); } else (*hops)[i].enctlv = NULL; if (tinvoice) { (*hops)[i].invoice = json_tok_bin_from_hex(*hops, buffer, tinvoice); if (!(*hops)[i].invoice) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'invoice' is invalid", name, i); } else (*hops)[i].invoice = NULL; if (tinvoicereq) { (*hops)[i].invoice_req = json_tok_bin_from_hex(*hops, buffer, tinvoicereq); if (!(*hops)[i].invoice_req) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'invoice_request' is invalid", name, i); } else (*hops)[i].invoice_req = NULL; if (tinvoiceerr) { (*hops)[i].invoice_err = json_tok_bin_from_hex(*hops, buffer, tinvoiceerr); if (!(*hops)[i].invoice_err) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'invoice_request' is invalid", name, i); } else (*hops)[i].invoice_err = NULL; if (trawtlv) { (*hops)[i].rawtlv = json_tok_bin_from_hex(*hops, buffer, trawtlv); if (!(*hops)[i].rawtlv) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s[%zu] 'rawtlv' is invalid", name, i); } else (*hops)[i].rawtlv = NULL; } return NULL; } static struct command_result *param_reply_path(struct command *cmd, const char *name, const char *buffer, const jsmntok_t *tok, struct tlv_onionmsg_payload_reply_path **reply_path) { const jsmntok_t *tblinding, *tpath, *t; size_t i; *reply_path = tal(cmd, struct tlv_onionmsg_payload_reply_path); tblinding = json_get_member(buffer, tok, "blinding"); if (!tblinding) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s has no 'blinding'", name); if (!json_to_pubkey(buffer, tblinding, &(*reply_path)->blinding)) return command_fail_badparam(cmd, name, buffer, tblinding, "'blinding' should be valid pubkey"); tpath = json_get_member(buffer, tok, "path"); if (!tpath || tpath->type != JSMN_ARRAY) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s has no 'path' array", name); (*reply_path)->path = tal_arr(*reply_path, struct onionmsg_path *, tpath->size); json_for_each_arr(i, t, tpath) { const jsmntok_t *tid, *tenctlv; struct onionmsg_path *path; path = (*reply_path)->path[i] = tal((*reply_path)->path, struct onionmsg_path); tid = json_get_member(buffer, t, "id"); if (!tid) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s path[%zu] 'id' is missing", name, i); if (!json_to_pubkey(buffer, tid, &path->node_id)) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s path[%zu] 'id' is invalid", name, i); tenctlv = json_get_member(buffer, t, "enctlv"); if (!tenctlv) { /* Optional for final destination */ if (i != tpath->size - 1) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s path[%zu] 'enctlv' is missing", name, i); path->enctlv = NULL; } else { path->enctlv = json_tok_bin_from_hex(path, buffer, tenctlv); if (!path->enctlv) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "%s path[%zu] 'enctlv' is invalid", name, i); } } return NULL; } /* Generate ->rawtlv if not already supplied. */ static void populate_tlvs(struct hop *hops, struct tlv_onionmsg_payload_reply_path *reply_path) { for (size_t i = 0; i < tal_count(hops); i++) { struct tlv_onionmsg_payload *tlv; if (hops[i].rawtlv) continue; tlv = tlv_onionmsg_payload_new(tmpctx); /* If they don't give scid, use next node id */ if (hops[i].scid) { tlv->next_short_channel_id = tal_dup(tlv, struct short_channel_id, hops[i].scid); } else if (i != tal_count(hops)-1) { tlv->next_node_id = tal_dup(tlv, struct pubkey, &hops[i+1].id); } if (hops[i].blinding) { tlv->blinding = tal_dup(tlv, struct pubkey, hops[i].blinding); } /* Note: tal_dup_talarr returns NULL for NULL */ tlv->enctlv = tal_dup_talarr(tlv, u8, hops[i].enctlv); tlv->invoice = tal_dup_talarr(tlv, u8, hops[i].invoice); tlv->invoice_request = tal_dup_talarr(tlv, u8, hops[i].invoice_req); tlv->invoice_error = tal_dup_talarr(tlv, u8, hops[i].invoice_err); if (i == tal_count(hops)-1 && reply_path) tlv->reply_path = reply_path; hops[i].rawtlv = tal_arr(hops, u8, 0); towire_onionmsg_payload(&hops[i].rawtlv, tlv); } } static struct command_result *json_send_onion_message(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct hop *hops; struct tlv_onionmsg_payload_reply_path *reply_path; struct sphinx_path *sphinx_path; struct onionpacket *op; struct secret *path_secrets; struct node_id first_id; size_t onion_size; if (!param(cmd, buffer, params, p_req("hops", param_hops, &hops), p_opt("reply_path", param_reply_path, &reply_path), NULL)) return command_param_failed(); if (!feature_offered(cmd->ld->our_features->bits[NODE_ANNOUNCE_FEATURE], OPT_ONION_MESSAGES)) return command_fail(cmd, LIGHTNINGD, "experimental-onion-messages not enabled"); node_id_from_pubkey(&first_id, &hops[0].id); /* Sanity check first; gossipd doesn't bother telling us if peer * can't be reached. */ if (!peer_by_id(cmd->ld, &first_id)) { /* Nasty hack: maybe we didn't know y-parity? */ first_id.k[0] = SECP256K1_TAG_PUBKEY_ODD; if (!peer_by_id(cmd->ld, &first_id)) return command_fail(cmd, LIGHTNINGD, "Unknown first peer"); /* Fixup first hop parity. */ if (!pubkey_from_node_id(&hops[0].id, &first_id)) return command_fail(cmd, LIGHTNINGD, "Could not convert parity!"); } /* Create an onion which encodes this. */ populate_tlvs(hops, reply_path); sphinx_path = sphinx_path_new(cmd, NULL); for (size_t i = 0; i < tal_count(hops); i++) { /* FIXME: Remove legacy, then length prefix can be removed! */ u8 *tlv_with_len = tal_arr(NULL, u8, 0); towire_bigsize(&tlv_with_len, tal_bytelen(hops[i].rawtlv)); towire_u8_array(&tlv_with_len, hops[i].rawtlv, tal_bytelen(hops[i].rawtlv)); sphinx_add_hop(sphinx_path, &hops[i].id, take(tlv_with_len)); } /* BOLT-offers #4: * - SHOULD set `len` to 1366 or 32834. */ if (sphinx_path_payloads_size(sphinx_path) <= ROUTING_INFO_SIZE) onion_size = ROUTING_INFO_SIZE; else onion_size = 32768; op = create_onionpacket(tmpctx, sphinx_path, onion_size, &path_secrets); if (!op) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "Creating onion failed (tlvs too long?)"); subd_send_msg(cmd->ld->gossip, take(towire_gossipd_send_onionmsg(NULL, &first_id, serialize_onionpacket(tmpctx, op), NULL))); return command_success(cmd, json_stream_success(cmd)); } static const struct json_command send_onion_message_command = { "sendonionmessage", "utility", json_send_onion_message, "Send message over {hops} (id, [short_channel_id], [blinding], [enctlv], [invoice], [invoice_request], [invoice_error], [rawtlv]) with optional {reply_path} (blinding, path[id, enctlv])" }; AUTODATA(json_command, &send_onion_message_command);