RFC 5338
Using the Host Identity Protocol with Legacy Applications
Title Block 🎀
Okay bestie, first the info box! 💅 This is RFC 5338, called "Using the Host Identity Protocol with Legacy Applications" ✨. It came out in September 2008 from the Network Working Group, and it's Informational, so it's not a standard, just a helpful guide 🦋. The authors are T. Henderson (The Boeing Company), P. Nikander (Ericsson Research NomadicLab), and M. Komu (Helsinki Institute for Information Technology) 🫶. The header doesn't list any RFCs it obsoletes or updates, so it's standing on its own 👑
Status of This Memo 📜
This memo gives information to the Internet community 🌈. It does not specify an Internet standard of any kind, and distribution of it is unlimited 💜.
Abstract 🦋
This doc is an informative overview of how legacy applications (apps that were built before HIP existed) can be made to work with the Host Identity Protocol (HIP) 🧚. HIP wants to add a cryptographic name space for network stack names 🔐. From the app's point of view, HIP-enabled systems get a brand new address family of host identifiers, but it could be a long time before HIP-aware apps are widely deployed, even once the hosts themselves are upgraded 😭.
This informational doc talks about implementation and Application Programming Interface (API) issues for when the system is HIP-aware but the apps aren't 💖. It's meant to help implementors and early adopters think through and locally solve the systems problems of rolling HIP out gradually 🍓.
Table of Contents 📚
1. Introduction ....................................................2
2. Terminology .....................................................3
3. Enabling HIP Transparently within the System ....................4
3.1. Applying HIP to Cases in Which IP Addresses Are Used .......4
3.2. Interposing a HIP-Aware Agent in the DNS Resolution ........6
3.3. Discussion .................................................7
4. Users Invoking HIP with a Legacy Application ....................8
4.1. Connecting to a HIT or LSI .................................8
4.2. Using a Modified DNS Name ..................................9
4.3. Other Techniques ...........................................9
5. Local Address Management ........................................9
6. Security Considerations ........................................11
7. Acknowledgments ................................................12
8. Informative References .........................................121. Introduction 🌸
The Host Identity Protocol (HIP) [RFC5201] is an experimental effort in the IETF and IRTF 🔬. It's studying a new public-key-based name space to use as host identifiers in Internet protocols 🔑. If HIP were fully deployed, apps and users could explicitly ask the system to send packets to another host, just by naming a peer with a location-independent unique name when they call connect or send 💫. The catch is there'll be a transition period where systems are HIP-enabled but apps aren't yet 😤. So this informational doc doesn't propose a normative spec, and it doesn't even suggest that HIP implementations standardize how they support legacy apps 🙅♀️. It's just here to help implementors and early adopters think through and solve the systems issues of incremental HIP deployment 🧚.
When apps and systems are both HIP-aware, they can coordinate really smoothly ✨. Using the sockets Application Programming Interface (API) lingo, the app can make a system call to send packets to a host by naming it directly, and the system does the name-to-address mapping and picks routable addresses for the packets 💅. To make this work, you'd define a new address family for hosts, and maybe add API extensions too, like letting IP addresses ride along in the system call with the host name as hints about where to try reaching the host first 🦋.
This doc does not define a native HIP API like that 🙈. Instead, it's about the situation where the app isn't HIP-aware and uses a traditional IP-address-based API 💜.
The sockets API discussion so far assumes apps are written directly against it. But lots of apps sit on top of middleware that exports a higher-level API to the app 🎀. For this doc, the middleware plus the middleware-based app together count as one overall application, or client of the sockets API 🫶.
When HIP is enabled on a system but the apps aren't HIP-aware, there are a few basic ways to use HIP, and any given HIP implementation may or may not support each one 🌈. This doc reports on techniques that experimental HIP implementations have used or considered 🔥. We organize everything around the policy for choosing whether to use HIP or expose it to apps 📋. Option one: users are totally unaware of HIP, or can't control whether it gets invoked, and the system just turns HIP on for some or all sessions based on policy 🤖. Option two: the user decides to try HIP and conveys that somehow within the limits of the unmodified app 🙋♀️. We'll dig into both use cases below 👑.
HIP was designed to work with unmodified apps, to make gradual rollout easier 🍓. For example, a HIT is the same size as an IPv6 address, so the design idea was that during early experiments and transition periods, HITs could stand in wherever IPv6 addresses were expected 🧚. But depending on the mechanism, that kind of use can change what apps consider an IP address to mean 😭. Apps use IP addresses as short-lived local handles, long-lived application associations, callbacks, referrals, and identity comparisons [APP-REF] 💖. The transition techniques below have different implications for those uses by legacy apps, and we'll try to point those out as we go ✨.
2. Terminology 💜
- Callback: The app at one end gets the peer's IP address and later uses it to communicate "back" to the peer 📞. An example is the FTP
PORTcommand 🎀. - Host Identity: An abstract concept applied to a computing platform 🖥️.
- Host Identifier (HI): A public key from an asymmetric key pair, used as a name for a Host Identity 🔑. More details are in [RFC5201] 📚.
- Host Identity Tag (HIT): A 128-bit quantity made from the hash of a Host Identity 🦋. More details are in [RFC4843] and [RFC5201] 💫.
- Local Scope Identifier (LSI): A 32- or 128-bit quantity that locally represents the Host Identity at the IPv4 or IPv6 API 🌸.
- Long-lived application associations: The app keeps the IP address for several instances of communication 🕰️.
- Referral: In an app with more than two parties, party B takes party A's IP address and passes it to party C 🧚. After that, party C uses the IP address to communicate with A 👑.
- Resolver: The system function apps use to resolve domain names to IP addresses 🔍.
- Short-lived local handle: The app never keeps the IP address. The only use is for the app to pass it from the DNS APIs (for example,
getaddrinfo()) to the protocol stack (for example,connect()orsendto()) 💅.
3. Enabling HIP Transparently within the System 🌈
When both users and apps are unaware of HIP, but the host administrator chooses to use HIP between hosts, there are a few options 🤓. The first basic option is to map the app-provided IP address to a host identifier inside the stack 🧩. The second option, if DNS is in use, is to interpose a local agent in the DNS resolution process, so the app gets back a HIT or a locally scoped handle that's formatted like an IP address 🦋.
Part 2 picks up right here in Section 3 💖
3.1. Applying HIP to Cases in Which IP Addresses Are Used
okay so picture this bestie 🦋 an app calls connect(ip) to set the default destination to some system at an address "ip", but the host admin wants HIP to protect the chat. the user and app just want to talk to whatever host lives at that IP address 💅 and the choice to turn HIP on has to be made based on host policy. like, when an IPsec-based HIP setup is in use, a policy can go into the security policy database saying to use or try HIP based on a match on source or destination IP address, port numbers, or other factors. iconic ✨
the mapping from IP address to host identifier can be done by modifying the host operating system, or by wrapping the existing sockets API, like the TESLA approach [TESLA] 🎀
there are a few ways the host admin could set HIP up in this situation 🧚
Manual configuration:
pre-existing Security Associations (SAs) might already be around from earlier admin work, or a binding between an IP address and a HIT could live in a config file or database. ngl very organized 🍓
Opportunistically:
the system could send an I1 to the Responder with an empty value for Responder HIT. bold move 🔥
Using DNS to map IP addresses to HIs:
if the Responder has host identifiers in the forward DNS zone and a PTR record in the reverse zone, the Initiator could do a reverse+forward lookup to learn the HIT tied to the address. it should work under normal circumstances 💖 but it has NOT been tested to make sure there are no recursion or bootstrapping issues, especially if HIP is used to secure the connection to the DNS servers 🙈 the security implications of using DNS Security (DNSSEC) or not using it get deferred to the Security Considerations section, so hold that thought bestie 🫶
using HIP this way can add setup delays compared to plain IP 😭 for opportunistic mode, a host has to wait to learn whether the peer is HIP-capable. the delays can be softened in some implementations by sending initial packets (e.g., TCP SYN) in parallel to the HIP I1 packet and waiting some time to receive a HIP R1 before processing a TCP SYN/ACK 🌈 but literally there is no specification yet for how to invoke those connections in parallel 💀 and DNS lookups can add resolution latency too 🌸
a possible way to cut those latencies, when the app uses DNS, is for the system to opportunistically query for HIP records in parallel with the other DNS resource records, temporarily cache the HITs returned, indexed by the IP addresses in the same entry, and then pass the IP addresses up to the app as usual. if the app connects to one of those IP addresses soon after the lookup, the host SHOULD initiate a base exchange using the cached HITs. the benefit? it removes the uncertainty and delay of opportunistic HIP, because the DNS record already suggests the peer is HIP-capable 👑✨
3.2. Interposing a HIP-Aware Agent in the DNS Resolution
in the last section we noted that a HIP-unaware app will usually use DNS to grab IP addresses before calling socket functions. a HIP-enabled system can use DNS to quietly fetch host identifiers for those domain names before the chat even starts 🧚
a system with a local DNS agent can alternately return a Local Scope Identifier (LSI) or HIT instead of an IP address, if HIP info is in the DNS or another directory that binds a domain name to a host identifier. otherwise it just returns an IP address like normal 💅 the system then keeps a mapping between LSI and host identifier and does the conversion at the system call interface or below. the app uses the LSI or HIT as if it were an IP address, no cap 🦋 this technique has shown up in overlay networking experiments like the Internet Indirection Infrastructure (i3), and at least one HIP implementation uses it too 🎀
when resolvers can return multiple destination identifiers, some of them can be HIP-based and the rest IPv4 or IPv6 addresses. the system resolver MAY put HIP-based identifiers in front of the list when the underlying system and policies support HIP. an app that works through the identifiers one by one will try the HIP connection first and only then the other non-HIP ones 💖 but certain apps launch connections in parallel, so the non-HIP connections might succeed before the HIP ones 😭 depending on local policy, a system may disallow that and return only HIP-based identifiers when they are found in DNS 🔥
if the app gets LSIs or HITs and treats them as IP addresses, a few hazards pop up 🙈 first, apps that do referrals might pass the LSI to another system that has no context to turn the LSI back into a host identifier or IP address. these are the same kinds of apps that will probably break behind certain NATs, so yeah, they're already a little fragile 🍓 second, apps may cache DNS results for a long time, and it can be hard for a HIP system to know when to garbage collect LSI bindings 💀 still, using HITs for identity comparison may be stronger security-wise than comparing IP addresses 💜
also, apps make log files, and admins or other log readers might get super confused seeing LSIs or HITs instead of IP addresses 😭 so it is RECOMMENDED that the HIP software logs the HITs, LSIs (if applicable), corresponding IP addresses, and Fully Qualified Domain Name (FQDN)-related information, so admins can match up other logs with HIP identifiers 🫶
it may be possible for an LSI or HIT to be routable or resolvable, directly or through an overlay. in that case it would be better for apps to use those names instead of IP addresses 🌈 but those networks are out of scope for this document, sorry bestie 🥺
3.3. Discussion
okay real talk, solutions that keep IP addresses in the apps are great for apps that use IP addresses for long-lived associations, callbacks, and referrals 💖 apps are discouraged from doing that because of how common NATs are [RFC1958] though, so keep that in mind 🙈 but they have WEAKER security properties than the approaches in Section 3.2 and Section 4, because the binding between host identifier and address is weak and invisible to the app or user 😭 the semantics of the app's "connect(ip)" call may mean "connect me to the system at IP address ip" and literally nothing stronger than that 💀 HIP can give perfect forward secrecy and authentication here, but it can NOT strongly authenticate the peer at the start of communications 🔥
using IP addresses at the app layer may not give you the full benefits of HIP mobility support 🦋 it allows mobility if the system can readdress long-lived, connected sockets when a HIP readdress event happens. however, like in current systems, mobility will break for connectionless traffic when an app caches the IP address and keeps calling sendto(), or for TCP when the system later opens more sockets to the same destination 😭
Section 4.1.6 of the base HIP protocol specification [RFC5201] says that implementations that learn HIT-to-IP address bindings through HIP opportunistic mode MUST NOT enforce those bindings on later communication sessions 💅 this means that when apps use IP addresses, systems that try to set up HIP opportunistically MUST NOT assume later sessions to the same address will reach the same host 👑
the legacy app doesn't know about HIP, so it can't tell the user when it's using HIP 🥺 but the operating system can notify the user about HIP usage through a user agent ✨ the user agent can even name the network app that caused a HIP-related event 🎀 so the user knows when they're using HIP even though the legacy app doesn't 💖 based on usability tests from early deployments, showing HITs and LSIs in user interfaces SHOULD be avoided 🙈 instead, use traditional security cues like lock icons and colored address bars where possible 🌸
one downside of spoofing DNS resolution is that some apps, or certain instances of an app, actually want IP addresses (like diagnostic tools such as ping) 🧚 one way to get finer control over whether the resolver returns an IP address or an LSI is to have the user build a modified domain name when they want HIP 💅 that brings us to the next section, where the end user explicitly and selectively chooses to turn HIP on 🦋
- Users Invoking HIP with a Legacy Application
the previous section covered ways to set up HIP for legacy apps that didn't necessarily involve the user 🌸 but sometimes a legacy app user wants HIP for one particular app instance, and they signal the HIP-enabled system somehow 👑 if the app's UI or config file accepts IP addresses, there may be a chance to put a HIT or an LSI in their place ✨ and if the app uses DNS, a user can type a specially crafted domain name to tell the resolver to fetch HIP records and tell the system to use HIP 🎀 we describe both of these approaches below, bestie 💖
4.1. Connecting to a HIT or LSI 🎀
okay so Section 3.2 above is about HITs or LSIs getting spoofed as return values from DNS resolution 🙈. A more explicit vibe is to configure the app to connect straight to a HIT, like connect(HIT) as a socket call 💅. This has stronger security semantics, bc the app is literally telling the system to send packets to that specific named peer 🔥. HITs were defined as Overlay Routable Cryptographic Hash Identifiers (ORCHIDs) so they can't get mixed up with routable IP addresses, see [RFC4843] ✨.
ngl this approach has its challenges 💀. HITs are kinda cumbersome for human users bc of the flat HIT name space, which is way harder than dealing with IPv6 addresses or domain names 🙃. Another challenge is figuring out which IP addresses to actually use based on the HIT. You'd need some kind of HIT resolution service for that 🧚. A third challenge is supporting callbacks and referrals to possibly non-HIP-aware hosts. But since most comms here would likely be to other HIP-aware hosts (else the initial HIP associations would fail to establish), the referral problem may be that the peer host supports HIP but can't do HIT resolution for some reason 🫶.
4.2. Using a Modified DNS Name 🦋
So if the app requests to resolve HIP-www.example.com (or some similar prefix string), the system returns an LSI 🌸. If the app requests to resolve www.example.com, IP address(es) come back as usual 💖. Using a prefix rather than a suffix is recommended, and so is using a string delimiter that isn't a dot ("."). This helps reduce the likelihood that these modified DNS names get mistakenly treated as names rooted at a new top-level domain 👑. Also, limits of domain name length or label length (255 or 63, respectively) should be considered when prepending any prefixes 📏.
4.3. Other Techniques 🌈
Alternatives to using a modified DNS name that have been experimented with include the following 🧪. The system can provide command-line tools or tools with a graphical user interface (GUI) so a user can set the policy on which apps use HIP 🎛️. Another common technique, for dynamically linked apps, is to dynamically link the app to a modified library that wraps the system calls and interposes HIP layer communications on them. The user can invoke this by running commands through a special shell, for example 🐚.
5. Local Address Management ✨
The previous two sections focused mainly on controlling client behavior (HIP initiator) 💁. We must also consider the behavior for servers 👀. Typically, a server binds to a wildcard IP address and well-known port 🔌. For HIP use with legacy server implementations, there are again a few options. The system may be configured manually to always, optionally (depending on the client behavior), or never use HIP with a particular service, as a matter of policy, when the server specifies a wildcard (IP) address 🧭.
When a system API call such as getaddrinfo [RFC3493] is used for resolving local addresses, it may also return HITs or LSIs, if the system has assigned HITs or LSIs to internal virtual interfaces (common in many HIP implementations) 🫧. The app may use such identifiers as addresses in subsequent socket calls 🧃.
Some apps may try to bind a socket to a specific local address, or may implement server-side access control lists based on socket calls such as getsockname() and getpeername() in the C-based socket APIs 🔐. If the local address specified is an IP address, again, the underlying system may be configured to still use HIP 🌷. If the local address specified is a HIT (Section 4), the system should enforce that connections to the local application can only arrive to the specified HIT 🚪. If a system has many HIs, an application that binds to a single HIT cannot accept connections to the other HIs but the one corresponding to the specified HIT 🙅.
When a host has multiple HIs and the socket behavior does not prescribe the use of any particular HI as a local identifier, it is a matter of local policy how to select a HI to serve as a local identifier 🤔. However, systems that bind to a wildcard may face problems when multiple HITs or LSIs are defined. These problems are not specific to HIP per se. They are also encountered in non-HIP multihoming scenarios with applications not designed for multihoming 🌀.
As an example, consider a client application that sends a UDP datagram to a server that is bound to a wildcard. The server application receives the packet using recvfrom() and sends a response using sendto(). The problem here is that sendto() may actually use a different server HIT than the client assumes. The client will drop the response packet when the client implements access control on the UDP socket (e.g., using connect()) 😱.
Reimplementing the server application using sendmsg() and recvmsg() to support multihoming (particularly considering the ancillary data) would be the ultimate solution to this problem, but with legacy applications it is not an option 🙏.
As a workaround, we make a suggestion for servers providing UDP-based services with non-multihoming-capable services. Such servers should announce only the HIT or public key that matches the default outgoing HIT of the host, to avoid such problems 🎯.
Finally, some applications may create a connection to a local HIT. In such a case, the local system may use NULL encryption to avoid unnecessary encryption overhead, and may be otherwise more permissive than usual, such as excluding authentication, Diffie-Hellman exchange, and puzzle 🧩.
6. Security Considerations 🔒
Big security energy here, bestie 😤. In this section, we discuss the security of the system in general terms, outlining some of the security properties. However, this section is not intended to provide a complete risk analysis. Such an analysis would, in any case, depend on the actual application using HIP, and is therefore considered out of scope 🚫.
The scenarios outlined above differ considerably in their security properties. When the DNS is used, there are further differences related to whether or not DNSSEC [RFC4033] is used, and whether the DNS zones are considered trustworthy enough. Here we mean that there should exist a delegation chain to whatever trust anchors are available in the respective trees, and the DNS zone administrators in charge of the netblock should be trusted to put in the right information 🌳.
When IP addresses are used by applications to name the peer system, the security properties depend on the configuration method. With manual configuration, the security of the system is comparable to a non-HIP system with similar IPsec policies. The security semantics of an initial opportunistic key exchange are roughly equal to non-secured IP. The exchange is vulnerable to man-in-the-middle attacks. However, the system is less vulnerable to connection hijacking attacks. If the DNS is used, and if both zones are secured (or the HITs are stored in the reverse DNS record) and the client trusts the DNSSEC signatures, the system may provide a fairly high security level. However, much depends on the details of the implementation, the security and administrative practices used when signing the DNS zones, and other factors 😬.
Using the forward DNS to map a domain name into an LSI is the case that is closest to the most typical use scenarios today. If DNSSEC is used, the result is fairly similar to the current use of certificates with Transport Layer Security (TLS). If DNSSEC is not used, the result is fairly similar to the current use of plain IP, with the additional protection of data integrity, confidentiality, and prevention of connection hijacking that opportunistic HIP provides. If DNSSEC is used, data integrity and data origin authentication services are added to the normal DNS query protocol, thereby providing more certainty that the desired host is being contacted, if the DNS records themselves are trustworthy 🔐.
If the application is basing its operations on HITs, the connections become automatically secured due to the implicit channel bindings in HIP. That is, when the application makes a connect(HIT) system call, either the resulting packets will be sent to a node possessing the corresponding private key, or the security association will fail to be established 🦋.
When the system provides (spoofs) LSIs or HITs instead of IP addresses as the result of name resolution, the resultant fields may inadvertently show up in user interfaces and system logs, which may cause operational concerns for some network administrators 📋. Therefore, it is recommended that the HIP software logs the HITs, LSIs (if applicable), corresponding IP addresses, and FQDN-related information, so that administrators can correlate other logs with HIP identifiers 🗂️.
7. Acknowledgments 🫶
Jeff Ahrenholz, Gonzalo Camarillo, Alberto Garcia, Teemu Koponen, Julien Laganier, and Jukka Ylitalo have provided comments on different versions of this document 💜. The document received substantial and useful comments during the review phase from David Black, Lars Eggert, Peter Koch, Thomas Narten, and Pekka Savola 🌟.
8. Informative References 📚
[RFC5201] Moskowitz, R., Nikander, P., Jokela, P., Ed., and T.
Henderson, "Host Identity Protocol", RFC 5201, April 2008.
[RFC4843] Nikander, P., Laganier, J., and F. Dupont, "An IPv6
Prefix for Overlay Routable Cryptographic Hash Identifiers
(ORCHID)", RFC 4843, April 2007.
[TESLA] Salz, J., Balakrishnan, H., and A. Snoeren, "TESLA: A
Transparent, Extensible Session-Layer Architecture for
End-to-end Network Services", Proceedings of USENIX
Symposium on Internet Technologies and Systems (USITS),
pages 211-224, March 2003.
[RFC1958] Carpenter, B., Ed., "Architectural Principles of the
Internet", RFC 1958, June 1996.
[RFC4033] Arends, R., Austein, R., Larson, M., Massey, D., and S.
Rose, "DNS Security Introduction and Requirements", RFC
4033, March 2005.
[RFC3493] Gilligan, R., Thomson, S., Bound, J., McCann, J., and W.
Stevens, "Basic Socket Interface Extensions for IPv6", RFC
3493, February 2003.
[APP_REF] Nordmark, E., "Shim6 Application Referral Issues", Work in
Progress, July 2005.Authors' Addresses 🖊️
Thomas Henderson
The Boeing Company
P.O. Box 3707
Seattle, WA
USA
EMail: thomas.r.henderson@boeing.com
Pekka Nikander
Ericsson Research NomadicLab
JORVAS FIN-02420
FINLAND
Phone: +358 9 299 1
EMail: pekka.nikander@nomadiclab.com
Miika Komu
Helsinki Institute for Information Technology
Metsaenneidonkuja 4
Helsinki FIN-02420
FINLAND
Phone: +358503841531
EMail: miika@iki.fiFull Copyright Statement ✨
Okay bestie, time for the legal stuff 📜💖 Copyright (C) The IETF Trust (2008). This doc is covered by the rights, licenses and restrictions in BCP 78, and the authors keep all their rights except where BCP 78 says otherwise 🎀
The fine print: this is provided on an "AS IS" basis, and the contributor, the org they represent or are sponsored by (if any), the Internet Society, the IETF Trust and the Internet Engineering Task Force all disclaim every warranty, express or implied. That includes no promise that using the info won't infringe anyone's rights, and no implied warranties of merchantability or fitness for a particular purpose. Ngl that's a lot of legalese 💀
Intellectual Property 🦋
Quick vibe check on IP: the IETF doesn't take a side on whether any intellectual property rights covering the tech in here are valid, how far they reach, or whether you can get a license for them. It also doesn't claim it went looking for those rights itself 🙈 If you want the rules on rights in RFC docs, check BCP 78 and BCP 79.
Copies of IPR disclosures sent to the IETF Secretariat live in the IETF online IPR repository at http://www.ietf.org/ipr. You'll also find any assurances of licenses that have been made available there, plus the results of any attempt to get a general license or permission for implementers or users to use those proprietary rights.
And the IETF totally invites anyone who knows about copyrights, patents, patent applications or other proprietary rights that might cover tech needed to implement this standard to tell them 🫶 Send that info to ietf-ipr@ietf.org. Bestie, speak up! 📣🌈
📦 where this page comes from
- ietf: rfc5338 2008-09
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms