RFC 2726

Network Working Group 💖

RFC: 2726 🦋 Title: PGP Authentication for RIPE Database Updates ✨ Author: J. Zsako (BankNet) 🎀 Category: Standards Track 👑 Date: December 1999 🌸 Obsoletes / Updates: This document doesn't list any RFCs it obsoletes or updates 🙈

---

Status of this Memo ✨

okay bestie, first the boring-but-important bit 💅 this document is an Internet standards track protocol for the Internet community, and it's basically inviting everyone to talk about it and suggest improvements 🫶 to check where the protocol stands right now, look at the current edition of the "Internet Official Protocol Standards" (STD 1). distribution of this memo is unlimited, so share it with everyone 🌈

Copyright Notice 🔥

Copyright (C) The Internet Society (1999). All Rights Reserved. 💜

Abstract 🧚

this doc is about a stronger way to authenticate people who update the RIPE database, using digital signatures 🔐 the proposal tries to stay general about which signing methods it covers, but it mainly focuses on PGP because that's the first method it's going to be implemented with 💖 it came out of the discussions in the RIPE DBSEC Task Force, so it's a whole group effort 🫶

---

1. Rationale 🎀

okay so the problem is that people need a stronger way to prove they're the database maintainer when they add, change, or delete objects in the database 😭 the existing methods are kinda broken, ngl. MAIL-FROM is a total mess because a mail header is super easy to forge 💀 and CRYPT-PW has a different problem, because the password gets sent unencrypted in the update mail, so anyone who intercepts the message can see it 🙈

the goal was to build a digital signature mechanism using tech that's already widely available and deployed 🌸 PGP was the first pick, and other methods might come later. PGP is already pretty popular across the Internet community, and it's available both inside and outside the US ✨

the current aim is just an improved authentication method, and that's it. this paper isn't trying to cover authorization stuff beyond what's related to authentication 🙅‍♀️ (main character focus only, bestie 💅)

---

2. Changes to the RIPE database 🌈

so to keep the database as self-consistent as possible, the key certificates get stored right in the RIPE database 💜 for efficiency there's also a local keyring of public keys, but that keyring only holds copies of the key certificates that are already in the database. the two get synced as often as possible ⭐ database objects are only created through the current e-mail mechanism (auto-dbm@ripe.net), and the database software will never fetch a public key certificate from a key server on its own 🫶

because the certs live in the database, users can check the "identity" of the maintainer 🕵️‍♀️ they can query the database for the certificate of the key the software uses to authenticate the maintainer, then look for existing signatures on it and compare it with a certificate they got another way for the same person (like from the owner directly, or from a public key server) 👑 the database can store a key certificate with any number of signatures, but since the RIPE database doesn't talk to public key servers directly, it's a good practice to add the cert with the fewest signatures possible. ideally just one: the one from itself 💅 see also section 4. for more details 🦋

2.1. The key-cert object 🔥

okay so a new object type is defined for storing the maintainers' key certificates 🎀 here's the layout:

key-cert:  [mandatory]  [single]     [primary/look-up key]
method:    [generated]  [single]     [ ]
owner:     [generated]  [multiple]   [ ]
fingerpr:  [generated]  [single]     [ ]
certif:    [mandatory]  [single]     [ ]
remarks:   [optional]   [multiple]   [ ]
notify:    [optional]   [multiple]   [inverse key]
mnt-by:    [mandatory]  [multiple]   [inverse key]
changed:   [mandatory]  [multiple]   [ ]
source:    [mandatory]  [single]     [ ]

the syntax and semantics of each attribute are described below 🧚

key-cert: this is always in the form PGPKEY-hhhhhhhh, where hhhhhhhh is the hex representation of the four-byte ID of the PGP key 🌸 the certificate in the certif attribute belongs to the PGP key with that ID. the PGPKEY- prefix is there so other kinds of key certificates can be added later 💖 it also lets you clearly tell apart a person query from a key certificate query at lookup time 👀 when a key-cert object is created or modified, the database software checks that the certificate in certif actually belongs to the PGP ID named here. the create or modify only goes through if the two IDs match 🫶

method: a line with the name of the signing method 💅 it's the name of the digital signature method, and it says the certificate belongs to a key that signs messages using that method ✨ this attribute is generated automatically by the database software when the key-cert object is created, so if you submit a method attribute yourself, it gets ignored 🙈 the method has to be consistent with both the prefix of the ID in the key-cert attribute and the certificate in certif. if those two (the prefix and the certificate) don't match, the key-cert creation gets refused 🔥 for the PGP method, the string is "PGP" (without the quotes) 🎀

owner: a line describing the owner of the key 👑 for a PGP key, the owners are the user IDs attached to the key 💜 for each user ID in the key certificate, the database software automatically generates an owner attribute when the key-cert object is created. any owner attribute you include in the submission is ignored 🌈

fingerpr: a set of hex-encoded bytes, separated by spaces for readability ⭐ it's the fingerprint of the key tied to this certificate 🦋 this is also generated when the object is created, so any fingerpr you submit gets ignored 🙅‍♀️ the whole point of this attribute (and owner) is an easy check of the key certificate when someone queries the database 🔍 the querier gets the owner and fingerprint without having to import the certificate into their own public keyring 💅 and since the database software generates these two from the certificate, you can trust them (as much as you can trust the database itself) 🫶

certif: a line from the ASCII-armoured key certificate 🧁 the certif lines together make up the key certificate. for PGP, they also include the delimiting lines (BEGIN PGP PUBLIC KEY BLOCK and END PGP PUBLIC KEY BLOCK) 🎀 the order of the lines is absolutely essential, so certif lines come back in query results in the same order they were submitted ✨ a database client can run a script that strips the leading certif: string and the whitespace after it from the returned lines, then imports the rest into the local keyring 🔐

mnt-by: this uses the usual syntax and the usual semantics, and this attribute is mandatory for this object 🌸 that means a mntner object has to exist before a key-cert object can be created 💖 the mntner referenced in mnt-by can't have its auth attribute set to NONE 🙅‍♀️

remarks, notify, changed, source: these use the usual syntax and semantics 🫶

for PGP, when a key-cert object is created, its key also gets added to the local keyring of public keys 🔑 when a key-cert object is deleted, the matching public key is removed from the local keyring too 🗑️ whenever a key-cert object is modified, the old key gets deleted from the local keyring and the key for the new certificate gets added 👑 (this only happens when the database update is authorized, and in particular only if the new key certificate actually belongs to the ID named in the key-cert attribute, as described above ✨)

2.2. Changes to the mntner object 💅

the only change is a new possible value for the auth attribute 🎀 that value is in the form PGPKEY-<id>, where <id> is the hex representation of the four-byte ID of the PGP public key used for authentication 🦋

what this new value means is that the PGP key tied to the key certificate stored in the key-cert object identified by PGPKEY-id is used to check the signature on any create, modify, or delete message sent to auto-dbm@ripe.net that affects an object maintained by this mntner 🔐 it's giving security upgrade 🌈

like other values, auth can appear multiple times 💜 but it doesn't really make sense to have two auth attributes with different methods (for example PGPKEY-<id> and NONE :)) ) 🙈 that was already true before this, too 💀

if there are several auth methods with a PGPKEY-<id> value, the meaning is the one that was already known: either signature is accepted 🫶✨

3. The PGP signed creation/modification/deletion ✨

bestie, the whole message has to be signed 🔒 🎀 The database software first checks whether the message is a PGP signed message. If it is, it checks for a valid signature and links that signature to the objects in the message. A message may contain only one PGP signature.

If an object in a message has a mnt-by attribute, and the matching mntner has auth attribute(s) with a PGPKEY-<id> value, the database software checks three things. First, the object has to have a signature attached (so the message had to be signed). Second, the signature type has to be PGP, which is the only type in this implementation phase. Third, the id of the key that signed the message has to match one of the auth attribute(s). The creation, modification or deletion of the object only goes through if this authentication succeeds 💅

This approach keeps message parsing simple ✨ A different approach would be needed if you signed the objects instead of the update messages. The parser would then have to figure out which objects were signed, check the signature(s) on each object one by one, and allow or refuse the update at the object level. That decision would depend on things like whether the signature is valid and whether it belongs to one of the maintainer(s). Object-level signing would allow objects signed by different maintainers to be mixed into the same e-mail message, which would probably not be typical 🙈 It would also allow the signature to be stored in the database, so it could be verified at query time. Storing the signatures in the database is beyond the scope of the first phase of the implementation. It may become a goal at a later date 🦋

It is recommended to check that your mailer program does not make any transformations to the text of the e-mail message, and to configure it not to do any if possible. Common transformations include line-wrapping after a given number of characters, converting tabs into spaces, and so on. Also check that you only use ASCII characters in the message 💜

4. Requirements the PGP key certificates must meet

There is no limitation on the version of PGP software that was or is used to create the key. Keys from both version 2.x and 5.0 are supported, although keys generated with version 5.0 are recommended 🌈

The key certificates submitted for creating a key-cert object must contain a signature of the key itself. The certificate may contain other signatures as well, but it is recommended to create the key-cert object with as few signatures in the certificate as possible ✨ Anyone concerned about the trustfulness of the key should retrieve a copy of the key certificate from a public key server (or by any other appropriate means) and check the signatures present in that certificate. If you do this check, take care to compare both the key fingerprint and the key type and length. That way you can be sure the two certificates (the one retrieved from the RIPE database and the one from the public key server or collected by other means) belong to the same key 🔍

Although it is highly unlikely, a key-cert with an id identical to the id of a maintainer's key may already exist in the RIPE database. If that key had been used for a while and registered at public key servers for some time, the person should contact the RIPE NCC and report this to ripe-dbm@ripe.net. Either way, they may have to create a new key and register its certificate in the RIPE database. This procedure is highly unlikely to happen, and it should not create serious problems for the respective maintainer 🫶

5. Short overview of the tasks to be performed in order to use PGP authentication

Here's the quick checklist, bestie 📝

1. You must have a mntner object in the RIPE database with auth: other than NONE. The mntner object has to be created in the traditional way.
2. You must get a certificate of your own key and prepare a key-cert object from it. The object has to reference the mntner mentioned above in mnt-by.
3. Create the key-cert object in the RIPE database by sending the object prepared above to auto-dbm@ripe.net. Obviously you must pass the authentication checks required by the mntner object (i.e. mail from a predefined address or send the correct password) 🔐
4. Change the mntner object so it has the auth: attribute value PGPKEY-<id>, where <id> is the hex id of your PGP key.
5. Check all objects maintained by the given mntner (preferably with the command. This is the only way to benefit from the stronger authentication method, and it helps the database become more trustworthy. Remember that you are the only person who can check for and correct possible inconsistencies 👑
6. From now on, always sign the (whole) update messages that refer to objects maintained by you, with the key you submitted to the RIPE database 💖

6. Example of objects using the new feature

Here's what it looks like in the wild, bestie 🧚 First, a mntner object with the PGP auth attribute:

mntner:      AS3244-MNT
descr:       BankNet, Budapest HU
descr:       Eastern European Internet Provider via own VSAT network
admin-c:     JZ38
tech-c:      JZ38
tech-c:      IR2-RIPE
upd-to:      ncc@banknet.net
mnt-nfy:     ncc@banknet.net
auth:        PGPKEY-23F5CE35
remarks:     This is the maintainer of all BankNet related objects
notify:      ncc@banknet.net
mnt-by:      AS3244-MNT
changed:     zsako@banknet.net 19980525
source:      RIPE

And here's the key-cert object it points to, with the full certificate block:

key-cert: PGPKEY-23F5CE35
method:   PGP
owner:    Janos Zsako <zsako@banknet.net>
fingerpr: B5 D0 96 D0 D0 D3 2B B2  B8 C2 5D 22 D4 F5 78 92
certif: -----BEGIN PGP PUBLIC KEY BLOCK-----
 Version: 2.6.2i
+
 mQCNAzCqKdIAAAEEAPMSQtBNFFuTS0duoUiqnPHm05dxrI76rrOGwx+OU5tzGavx
 cm2iCInNtikeKjlIMD7FiCH1J8PWdZivpwhzuGeeMimT8ZmNn4z3bb6ELRyiZOvs
 4nfxVlh+kKKD9JjBfy8DnuMs5sT0jw4FEt/PYogJinFdndzywXHzGHEj9c41AAUR
 tB9KYW5vcyBac2FrbyA8enNha29AYmFua25ldC5uZXQ+iQCVAwUQMjkx2XHzGHEj
 9c41AQEuagP/dCIBJP+R16Y70yH75kraRzXY5rnsHmT0Jknrc/ihEEviRYdMV7X1
 osP4pmDU8tNGf0OfGrok7KDTCmygIh7/me+PKrDIj0YkAVUhBX3gBtpSkhEmkLqf
 xbhYwDn4DV3zF7f5AMsbD0UCBDyf+vpkMzgd1Pbr439iXdgwgwta50qJAHUDBRAy
 OSsrO413La462EEBAdIuAv4+Cao1wqBG7+gIm1czIb1M2cAM7Ussx6y+oL1d+HqN
 PRhx4upLVg8Eqm1w4BYpOxdZKkxumIrIvrSxUYv4NBnbwQaa0/NmBou44jqeN+y2
 xwxAEVd9BCUtT+YJ9iMzZlE=
 =w8xL
 -----END PGP PUBLIC KEY BLOCK-----
remarks: This is an example of PGP key certificate
mnt-by:  AS3244-MNT
changed: zsako@banknet.net 19980525
source:  RIPE

7. Security Considerations

bestie, this part is serious 😭 This document addresses authentication of transactions for making additions, deletions, and updates to the routing policy information through strong cryptographic means. The authorization of these transactions is addressed in [1] 🔥

8. Acknowledgements

The present proposal came out of the discussions within the RIPE DBSEC Task Force, which was set up at RIPE 27 in Dublin at the initiative of Joachim Schmitz and Wilfried Woeber 🌸 The people who contributed to the discussions on different ocasions (TF meetings and via e-mail) are, in alphabetical order: Cengiz Allaettinoglu, Joao Luis Silva Damas, Havard Eidnes, Chris Fletcher, Daniel Karrenberg, David Kessens, Jake Khuon, Craig Labovitz, Carl Malamud, Dave Meyer, Maldwyn Morris, Sandy Murphy, Mike Norris, Carol Orange, Joachim Schmitz, Tom Spindler, Don Stikvoort, Curtis Villamizar, Gerald Winters, Wilfried Woeber, Janos Zsako 🦋

9. References

[1]  Meyer, D., Villamizar, C., Alaettinoglu, C. and S.  Murphy,
     "Routing Policy System Security", RFC 2725, December 1999.

10. Author's Address

Janos Zsako
BankNet
1121 Budapest
Konkoly-Thege ut 29-33.
Hungary

Phone: +36 1 395 90 28
Fax:   +36 1 395 90 32
EMail: zsako@banknet.net

11. Notices

PGP is a commercial software 💅

The IETF takes no position on the validity or scope of any intellectual property or other rights that might be claimed to apply to the implementation or use of the technology described in this document, or on the extent to which any license under such rights might or might not be available. It also doesn't say it has made any effort to identify such rights. Information on the IETF's procedures for rights in standards-track and standards-related documentation can be found in BCP-11. Copies of claims of rights made available for publication, any assurances of licenses to be made available, or the result of an attempt to obtain a general license or permission for implementors or users to use such proprietary rights, can be obtained from the IETF Secretariat 🧾

The IETF invites any interested party to bring to its attention any copyrights, patents or patent applications, or other proprietary rights which may cover technology that may be required to practice this standard. Please send that information to the IETF Executive Director 📬

12. Full Copyright Statement

Copyright (C) The Internet Society (1999). All Rights Reserved. 🌈

This document and translations of it may be copied and furnished to others. Derivative works that comment on or otherwise explain it, or assist in its implementation, may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations. The exceptions are when it's needed for developing Internet standards, in which case the procedures for copyrights defined in the Internet Standards process must be followed, or when it's required to translate it into languages other than English 🌸

The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns ⭐

This document and the information contained herein is provided on an "AS IS" basis, and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 💀

Acknowledgement

Funding for the RFC Editor function is currently provided by the Internet Society 🫶