RFC 4648
The Base16, Base32, and Base64 Data Encodings
RFC 4648: The Base16, Base32, and Base64 Data Encodings 💖
- Stream: Network Working Group
- Author: S. Josefsson (SJD)
- Date: October 2006
- Category: Standards Track
- Obsoletes: RFC 3548
- Part: 1 of 3 🎀
Status of This Memo
Okay bestie, this one is an Internet standards track protocol for the Internet community ✨ It's asking for discussion and suggestions for improvements, so speak up! For the standardization state and status of this protocol, check the current edition of the "Internet Official Protocol Standards" (STD 1). And the vibe is super open: distribution of this memo is unlimited 🦋
Copyright Notice
Copyright (C) The Internet Society (2006). 💜
Abstract
This doc is all about the commonly used base 64, base 32, and base 16 encoding schemes 🌈 It also spills the tea on line-feeds in encoded data, padding in encoded data, non-alphabet characters in encoded data, using different encoding alphabets, and canonical encodings. Iconic lineup, honestly 👑
Table of Contents
1. Introduction ....................................................3
2. Conventions Used in This Document ...............................3
3. Implementation Discrepancies ....................................3
3.1. Line Feeds in Encoded Data .................................3
3.2. Padding of Encoded Data ....................................4
3.3. Interpretation of Non-Alphabet Characters in Encoded Data ..4
3.4. Choosing the Alphabet ......................................4
3.5. Canonical Encoding .........................................5
4. Base 64 Encoding ................................................5
5. Base 64 Encoding with URL and Filename Safe Alphabet ............7
6. Base 32 Encoding ................................................8
7. Base 32 Encoding with Extended Hex Alphabet ....................10
8. Base 16 Encoding ...............................................10
9. Illustrations and Examples .....................................11
10. Test Vectors ..................................................12
11. ISO C99 Implementation of Base64 ..............................14
12. Security Considerations .......................................14
13. Changes Since RFC 3548 ........................................15
14. Acknowledgements ..............................................15
15. Copying Conditions ............................................15
16. References ....................................................16
16.1. Normative References .....................................16
16.2. Informative References ...................................161. Introduction ✨
Okay so base encoding is used all over the place to store or transfer data in environments that are, maybe for legacy reasons, stuck with US-ASCII [1] data. 🥹 It's also useful in brand-new apps with no legacy baggage, simply because it lets you poke at objects with a regular text editor. Main character energy for data 💅
Here's the tea: different apps have had different needs, so they sometimes built base encodings in slightly different ways 🙈 Protocol specs also love to say "base64" (or base encodings in general) without giving a precise description or a reference. Multipurpose Internet Mail Extensions (MIME) [4] gets used as the go-to reference for base64, but people often skip thinking about the consequences for line-wrapping or non-alphabet characters. So this spec is here to set a common alphabet and common encoding considerations. The goal is less ambiguity in other docs, which should lead to better interoperability 🫶
2. Conventions Used in This Document 📝
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in [2]. 🔥
3. Implementation Discrepancies 🌸
Here we dig into the discrepancies between base encoding implementations from the past and, where it makes sense, set a specific recommended behavior for the future 💖
3.1. Line Feeds in Encoded Data 🍓
Okay, MIME [4] is often used as a reference for base 64 encoding, but here's the twist: MIME doesn't define "base 64" per se. It defines a "base 64 Content-Transfer-Encoding" for use within MIME 🤭 Because of that, MIME enforces a limit on line length of base 64-encoded data, set to 76 characters. MIME inherits the encoding from Privacy Enhanced Mail (PEM) [3] and calls it "virtually identical," but PEM uses a line length of 64 characters. Both the MIME and PEM limits are due to limits within SMTP ✉️
Now the rule, bestie: Implementations MUST NOT add line feeds to base-encoded data unless the specification referring to this document explicitly directs base encoders to add line feeds after a specific number of characters. 🚫
3.2. Padding of Encoded Data 🎀
Sometimes the padding (=) in base-encoded data isn't required or used at all 🤷♀️ In the general case, though, when assumptions about the size of transported data can't be made, padding is required to get correct decoded data. It's giving "you need this" 💅
Rule time: Implementations MUST include appropriate pad characters at the end of encoded data unless the specification referring to this document explicitly states otherwise.
The base64 and base32 alphabets use padding, as described below in sections 4 and 6. The base16 alphabet doesn't need it, so check section 8 for that one 🧚
3.3. Interpretation of Non-Alphabet Characters in Encoded Data 👀
Base encodings use a specific, reduced alphabet to encode binary data. Non-alphabet characters could still show up in base-encoded data, whether from data corruption or on purpose 😳 They can be abused as a "covert channel," where non-protocol data gets sent for nefarious purposes. Non-alphabet characters might also be sent to exploit implementation errors that lead to, e.g., buffer overflow attacks 💀 Not okay!!
So, bestie, the rule is: Implementations MUST reject the encoded data if it contains characters outside the base alphabet when interpreting base-encoded data, unless the specification referring to this document explicitly states otherwise. Some specs may instead say, the way MIME does, that characters outside the base encoding alphabet should simply be ignored when interpreting data ("be liberal in what you accept") 🌈 Heads up: this means any adjacent carriage return/line feed (CRLF) characters count as "non-alphabet characters" and get ignored. Also, such specs MAY ignore the pad character, =, treating it as non-alphabet data, if it's present before the end of the encoded data. And if there are more pad characters than allowed at the end of the string (say, a base 64 string ending in ===), the excess pad characters MAY also be ignored 🫶
3.4. Choosing the Alphabet 🦋
Different apps have different requirements on the characters in the alphabet. Here are a few requirements that decide which alphabet should be used:
- Handled by humans. The characters "0" and "O" are easily confused, and so are "1", "l", and "I". In the base32 alphabet below, 0 (zero) and 1 (one) aren't present, so a decoder may interpret 0 as O, and 1 as I or L depending on case. (However, by default it should not; see previous section.) 🙈
- Encoded into structures that mandate other requirements. For base 16 and base 32, this decides whether you use upper- or lowercase alphabets. For base 64, the non-alphanumeric characters (in particular, "/") may be problematic in file names and URLs 📁
- Used as identifiers. Certain characters, notably "+" and "/" in the base 64 alphabet, get treated as word-breaks by legacy text search/index tools 🔍
Honest truth: there's no universally accepted alphabet that fulfills all the requirements 😭 For an example of a highly specialized variant, see IMAP [8]. In this document, we document and name some alphabets that are currently in use ✨
3.5. Canonical Encoding 💎
The padding step in base 64 and base 32 encoding can, if it's implemented badly, lead to non-significant alterations of the encoded data 😬 For example, if the input is only one octet for a base 64 encoding, then all six bits of the first symbol get used, but only the first two bits of the next symbol get used. These pad bits MUST be set to zero by conforming encoders, which is described in the padding descriptions below. If this property does not hold, there's no canonical representation of base-encoded data, and multiple base-encoded strings can decode to the same binary data. If this property (and the others discussed in this document) holds, a canonical encoding is guaranteed. Lowkey the most important bit of this whole section 🔥
In some environments, the alteration is critical, so decoders MAY chose to reject an encoding if the pad bits haven't been set to zero. The specification referring to this may mandate a specific behaviour 💅
4. Base 64 Encoding 💖
okay so this description of base 64 is derived from [3], [4], [5], and [6]. this encoding may be referred to as "base64" 🎀
base64 is designed to represent arbitrary sequences of octets in a form that lets you use both upper- and lowercase letters, but it doesn't need to be human readable. no one is reading this raw, and that's fine ✨
it uses a 65-character subset of US-ASCII, so each printable character carries 6 bits 🧚 the extra 65th character, "=", is used to signify a special processing function. it's the padding bestie 🫶
the encoding process turns 24-bit groups of input bits into output strings of 4 encoded characters. going from left to right, a 24-bit input group is made by sticking 3 8-bit input groups together. then those 24 bits get treated as 4 concatenated 6-bit groups, and each one is translated into a single character in the base 64 alphabet 💅
each 6-bit group is used as an index into an array of 64 printable characters. whatever character the index points to goes into the output string. the lookup table is right here:
Table 1: The Base 64 Alphabet
Value Encoding Value Encoding Value Encoding Value Encoding
0 A 17 R 34 i 51 z
1 B 18 S 35 j 52 0
2 C 19 T 36 k 53 1
3 D 20 U 37 l 54 2
4 E 21 V 38 m 55 3
5 F 22 W 39 n 56 4
6 G 23 X 40 o 57 5
7 H 24 Y 41 p 58 6
8 I 25 Z 42 q 59 7
9 J 26 a 43 r 60 8
10 K 27 b 44 s 61 9
11 L 28 c 45 t 62 +
12 M 29 d 46 u 63 /
13 N 30 e 47 v
14 O 31 f 48 w (pad) =
15 P 32 g 49 x
16 Q 33 h 50 yokay now the fun part 🌈 special processing kicks in if fewer than 24 bits are available at the end of the data being encoded. a full encoding quantum is always completed at the end of a quantity 🎀 when fewer than 24 input bits are in an input group, bits with value zero get added (on the right) so you end up with an integral number of 6-bit groups. padding at the end of the data is done with the '=' character. and since all base 64 input is an integral number of octets, only these cases can happen:
(1) the final quantum of encoding input is an integral multiple of 24 bits. here, the final unit of encoded output is an integral multiple of 4 characters with no "=" padding. clean ✨
(2) the final quantum of encoding input is exactly 8 bits. here, the final unit of encoded output is two characters followed by two "=" padding characters 🙈
(3) the final quantum of encoding input is exactly 16 bits. here, the final unit of encoded output is three characters followed by one "=" padding character 🦋
5. Base 64 Encoding with URL and Filename Safe Alphabet 🌸
the base 64 encoding with a URL and filename safe alphabet has been used in [12]. iconic history 👑
there was an alternative alphabet suggested that would use "~" as the 63rd character. but "~" has special meaning in some file system environments, so the encoding described in this section is recommended instead 💀 the remaining unreserved URI character is ".", but some file system environments don't allow multiple "." in a filename, so "." is unattractive too. not it 🙅♀️
the pad character "=" is typically percent-encoded when used in a URI [9]. but if the data length is known implicitly, you can avoid this by skipping the padding. see section 3.2 for the deets 🫶
this encoding may be referred to as "base64url". this encoding should not be regarded as the same as the "base64" encoding, and should not be referred to as only "base64". unless clarified otherwise, "base64" refers to the base 64 in the previous section. don't mix them up bestie 😭
this encoding is technically identical to the previous one, except for the 62:nd and 63:rd alphabet character, as shown in Table 2 ✨
Table 2: The "URL and Filename safe" Base 64 Alphabet
Value Encoding Value Encoding Value Encoding Value Encoding
0 A 17 R 34 i 51 z
1 B 18 S 35 j 52 0
2 C 19 T 36 k 53 1
3 D 20 U 37 l 54 2
4 E 21 V 38 m 55 3
5 F 22 W 39 n 56 4
6 G 23 X 40 o 57 5
7 H 24 Y 41 p 58 6
8 I 25 Z 42 q 59 7
9 J 26 a 43 r 60 8
10 K 27 b 44 s 61 9
11 L 28 c 45 t 62 - (minus)
12 M 29 d 46 u 63 _
13 N 30 e 47 v (underline)
14 O 31 f 48 w
15 P 32 g 49 x
16 Q 33 h 50 y (pad) =6. Base 32 Encoding 🍓
this description of base 32 is derived from [11] (with corrections). this encoding may be referred to as "base32" 🎀
base32 is designed to represent arbitrary sequences of octets in a form that needs to be case insensitive, but it doesn't need to be human readable. the vibe is all caps energy 💅
it uses a 33-character subset of US-ASCII, so each printable character carries 5 bits. (the extra 33rd character, "=", is used to signify a special processing function 🧚)
the encoding process turns 40-bit groups of input bits into output strings of 8 encoded characters. going from left to right, a 40-bit input group is made by concatenating 5 8bit input groups. then those 40 bits get treated as 8 concatenated 5-bit groups, and each one is translated into a single character in the base 32 alphabet. when a bit stream is encoded via base 32, the bit stream must be presumed to be ordered with the most-significant-bit first. so the first bit in the stream is the high-order bit in the first 8bit byte, the eighth bit is the low-order bit in the first 8bit byte, and so on 🔥
each 5-bit group is used as an index into an array of 32 printable characters. whatever character the index points to goes into the output string. these characters, shown in Table 3 below, are picked from US-ASCII digits and uppercase letters 🌈
Table 3: The Base 32 Alphabet
Value Encoding Value Encoding Value Encoding Value Encoding
0 A 9 J 18 S 27 3
1 B 10 K 19 T 28 4
2 C 11 L 20 U 29 5
3 D 12 M 21 V 30 6
4 E 13 N 22 W 31 7
5 F 14 O 23 X
6 G 15 P 24 Y (pad) =
7 H 16 Q 25 Z
8 I 17 R 26 2special processing is done if fewer than 40 bits are available at the end of the data being encoded. a full encoding quantum is always completed at the end of a body 🫶 when fewer than 40 input bits are in an input group, bits with value zero get added (on the right) to form an integral number of 5-bit groups. padding at the end of the data is done with the "=" character. since all base 32 input is an integral number of octets, only these cases can arise:
(1) the final quantum of encoding input is an integral multiple of 40 bits. here, the final unit of encoded output is an integral multiple of 8 characters with no "=" padding ✨
(2) the final quantum of encoding input is exactly 8 bits. here, the final unit of encoded output is two characters followed by six "=" padding characters 🙈
(3) the final quantum of encoding input is exactly 16 bits. here, the final unit of encoded output is four characters followed by four "=" padding characters 🦋
(4) the final quantum of encoding input is exactly 24 bits. here, the final unit of encoded output is five characters followed by three "=" padding characters 🌸
(5) the final quantum of encoding input is exactly 32 bits. here, the final unit of encoded output is seven characters followed by one "=" padding character 👑
7. Base 32 Encoding with Extended Hex Alphabet 🧚
this description of base 32 is derived from [7]. this encoding may be referred to as "base32hex". this encoding should not be regarded as the same as the "base32" encoding, and should not be referred to as only "base32". it's used by, e.g., NextSECure3 (NSEC3) [10] 💜
one property this alphabet has, which the base64 and base32 alphabets lack, is that encoded data keeps its sort order when the encoded data is compared bit-wise. main character energy 😭🔥
this encoding is identical to the previous one, except for the alphabet. the new alphabet is in Table 4 🎀
Table 4: The "Extended Hex" Base 32 Alphabet
Value Encoding Value Encoding Value Encoding Value Encoding
0 0 9 9 18 I 27 R
1 1 10 A 19 J 28 S
2 2 11 B 20 K 29 T
3 3 12 C 21 L 30 U
4 4 13 D 22 M 31 V
5 5 14 E 23 N
6 6 15 F 24 O (pad) =
7 7 16 G 25 P
8 8 17 H 26 Q8. Base 16 Encoding 🌈
the following description is original but analogous to the previous descriptions. essentially, base 16 encoding is the standard case-insensitive hex encoding, and it may be referred to as "base16" or "hex" 💅
a 16-character subset of US-ASCII is used, so each printable character carries 4 bits 🧚
the encoding process turns 8-bit groups (octets) of input bits into output strings of 2 encoded characters. going from left to right, an 8-bit input is taken from the input data. then those 8 bits get treated as 2 concatenated 4-bit groups, and each one is translated into a single character in the base 16 alphabet ✨
each 4-bit group is used as an index into an array of 16 printable characters. whatever character the index points to goes into the output string. here's the alphabet 🫶
Table 5: The Base 16 Alphabet
Value Encoding Value Encoding Value Encoding Value Encoding
0 0 4 4 8 8 12 C
1 1 5 5 9 9 13 D
2 2 6 6 10 A 14 E
3 3 7 7 11 B 15 Funlike base 32 and base 64, no special padding is necessary, since a full code word is always available 🎀
9. Illustrations and Examples ✨
okay so, to go between binary and a base encoding, you stash the input in a structure and then pull the output out of it 💅. The base 64 version is shown in this figure, borrowed from [5] 🦋
+--first octet--+-second octet--+--third octet--+
|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|
+-----------+---+-------+-------+---+-----------+
|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|
+--1.index--+--2.index--+--3.index--+--4.index--+The base 32 figure is from [7] 🌸 Each character in a base-32 value holds 5 bits of the underlying octets, so every group of 8 characters covers 5 octets (40 bits). It's giving tidy little puzzle energy 🧩
1 2 3
01234567 89012345 67890123 45678901 23456789
+--------+--------+--------+--------+--------+
|< 1 >< 2| >< 3 ><|.4 >< 5.|>< 6 ><.|7 >< 8 >|
+--------+--------+--------+--------+--------+
<===> 8th character
<====> 7th character
<===> 6th character
<====> 5th character
<====> 4th character
<===> 3rd character
<====> 2nd character
<===> 1st characterNext up is a Base64 example, taken from [5] and fixed up a bit 🎀 Watch how the 8-bit groups get split into 6-bit chunks, and how the padding shows up at the end 🫶
Input data: 0x14fb9c03d97e
Hex: 1 4 f b 9 c | 0 3 d 9 7 e
8-bit: 00010100 11111011 10011100 | 00000011 11011001 01111110
6-bit: 000101 001111 101110 011100 | 000000 111101 100101 111110
Decimal: 5 15 46 28 0 61 37 62
Output: F P u c A 9 l +
Input data: 0x14fb9c03d9
Hex: 1 4 f b 9 c | 0 3 d 9
8-bit: 00010100 11111011 10011100 | 00000011 11011001
pad with 00
6-bit: 000101 001111 101110 011100 | 000000 111101 100100
Decimal: 5 15 46 28 0 61 36
pad with =
Output: F P u c A 9 k =
Input data: 0x14fb9c03
Hex: 1 4 f b 9 c | 0 3
8-bit: 00010100 11111011 10011100 | 00000011
pad with 0000
6-bit: 000101 001111 101110 011100 | 000000 110000
Decimal: 5 15 46 28 0 48
pad with = =
Output: F P u c A w = =10. Test Vectors 🧪
these are the vibes check 💖 Every one of them should come out exactly like this, no cap 👑
BASE64("") = ""
BASE64("f") = "Zg=="
BASE64("fo") = "Zm8="
BASE64("foo") = "Zm9v"
BASE64("foob") = "Zm9vYg=="
BASE64("fooba") = "Zm9vYmE="
BASE64("foobar") = "Zm9vYmFy"
BASE32("") = ""
BASE32("f") = "MY======"
BASE32("fo") = "MZXQ===="
BASE32("foo") = "MZXW6==="
BASE32("foob") = "MZXW6YQ="
BASE32("fooba") = "MZXW6YTB"
BASE32("foobar") = "MZXW6YTBOI======"
BASE32-HEX("") = ""
BASE32-HEX("f") = "CO======"
BASE32-HEX("fo") = "CPNG===="
BASE32-HEX("foo") = "CPNMU==="
BASE32-HEX("foob") = "CPNMUOG="
BASE32-HEX("fooba") = "CPNMUOJ1"
BASE32-HEX("foobar") = "CPNMUOJ1E8======"
BASE16("") = ""
BASE16("f") = "66"
BASE16("fo") = "666F"
BASE16("foo") = "666F6F"
BASE16("foob") = "666F6F62"
BASE16("fooba") = "666F6F6261"
BASE16("foobar") = "666F6F626172"11. ISO C99 Implementation of Base64 💻
okay, there's an ISO C99 implementation of Base64 encoding and decoding that's believed to follow all the recommendations in this RFC 🌈 You can grab it at http://josefsson.org/base-encoding/. Just know it's not normative, so it's a helper, not the rulebook ✨
The code couldn't be included in this RFC for procedural reasons, which are covered in RFC 3978 section 5.4 🙈
12. Security Considerations 🔐
this section is seriously important, bestie 😭 When you implement base encoding and decoding, take care not to open the door to buffer overflow attacks or other attacks on the implementation. A decoder should not break on invalid input, including, e.g., embedded NUL characters (ASCII 0) 💀
If you ignore non-alphabet characters instead of rejecting the whole encoding (which is what's recommended), that opens a covert channel that can be used to "leak" information 🕵️♀️ Ignored characters could also get used for other nefarious stuff, like dodging a string equality comparison or setting off implementation bugs. Applications that don't follow the recommended practice should understand what ignoring those characters implies. Same deal with base 16 and base 32: if you treat the alphabet case-insensitively, changing the case can be used to leak information or make string equality comparisons fail 🚨
When padding is used, there are some non-significant bits that raise security concerns. They can be abused to leak information, to bypass string equality comparisons, or to trigger implementation problems 🙅♀️
Base encoding visually hides stuff that's otherwise easy to recognize, like passwords, but it does not give you any computational confidentiality 👀 This has caused real security incidents. For example, a user shares details of a network protocol exchange (maybe to illustrate some other problem) and accidentally reveals the password, because she didn't realize base encoding doesn't protect it 😭
Base encoding adds no entropy to the plaintext. It does increase the amount of plaintext available, though, and it gives cryptanalysis a signature in the form of a characteristic probability distribution 🔍
13. Changes Since RFC 3548 📝
here's the tea on what changed since RFC 3548 ☕
- Added the "base32 extended hex alphabet", which is needed to preserve sort order of encoded data 🍓
- Referenced IMAP for the special Base64 encoding used there 📬
- Fixed the example copied from RFC 2440 🛠️
- Added a security consideration about providing a signature for cryptoanalysis 🔐
- Added test vectors 🧪
- Fixed typos 💅
14. Acknowledgements 🫶
so many people helped make this happen 🥹 Several folks offered comments and/or suggestions, including John E. Hadstate, Tony Hansen, Gordon Mohr, John Myers, Chris Newman, and Andrew Sieber. Text used in this document is based on earlier RFCs that described specific uses of various base encodings. The author also thanks the RSA Laboratories for supporting the work that led to this document 🌸
This revised version is based in parts on comments and/or suggestions made by Roy Arends, Eric Blake, Brian E Carpenter, Elwyn Davies, Bill Fenner, Sam Hartman, Ted Hardie, Per Hygum, Jelte Jansen, Clement Kent, Tero Kivinen, Paul Kwiatkowski, and Ben Laurie 💜
15. Copying Conditions 📜
Copyright (c) 2000-2006 Simon Josefsson 🧚
Regarding the abstract and sections 1, 3, 8, 10, 12, 13, and 14 of this document, which were written by Simon Josefsson ("the author" for the rest of this section), the author makes no guarantees and isn't responsible for any damage that comes from using it. The author grants irrevocable permission to anyone to use, modify, and distribute it in any way that doesn't diminish anyone else's rights to use, modify, and distribute it. That's provided that redistributed derivative works don't contain misleading author or version information and don't falsely claim to be IETF RFC documents. Derivative works don't need to be licensed under similar terms 🦋
16. References 📚
16.1. Normative References
- [1] Cerf, V., "ASCII format for network interchange", RFC 20, October 1969.
- [2] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997.
16.2. Informative References
- [3] Linn, J., "Privacy Enhancement for Internet Electronic Mail: Part I: Message Encryption and Authentication Procedures", RFC 1421, February 1993.
- [4] Freed, N. and N. Borenstein, "Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies", RFC 2045, November 1996.
- [5] Callas, J., Donnerhacke, L., Finney, H., and R. Thayer, "OpenPGP Message Format", RFC 2440, November 1998.
- [6] Arends, R., Austein, R., Larson, M., Massey, D., and S. Rose, "DNS Security Introduction and Requirements", RFC 4033, March 2005.
- [7] Klyne, G. and L. Masinter, "Identifying Composite Media Features", RFC 2938, September 2000.
- [8] Crispin, M., "INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1", RFC 3501, March 2003.
- [9] Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, January 2005.
- [10] Laurie, B., Sisson, G., Arends, R., and D. Blacka, "DNSSEC Hash Authenticated Denial of Existence", Work in Progress, June 2006.
- [11] Myers, J., "SASL GSSAPI mechanisms", Work in Progress, May 2000.
- [12] Wilcox-O'Hearn, B., "Post to P2P-hackers mailing list",
http://zgp.org/pipermail/p2p-hackers/2001-September/000315.html, September 2001.
Author's Address 🏡
Simon Josefsson SJD EMail: simon@josefsson.org
Full Copyright Statement ©️
Copyright (C) The Internet Society (2006) 🌈
This document is subject to the rights, licenses and restrictions contained in BCP 78. Except as set forth there, the authors keep all their rights.
This document and the information in it are provided on an "AS IS" basis. THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED. That includes, but isn't limited to, any warranty that using the information here won't infringe any rights, and any implied warranties of merchantability or fitness for a particular purpose 🙏
Intellectual Property 🔏
The IETF takes no position on the validity or scope of any Intellectual Property Rights or other rights that might be claimed to pertain to implementing or using the technology described here. It also doesn't say whether any license under those rights might or might not be available, and it doesn't claim to have made any independent effort to find such rights. Info on the procedures for rights in RFC documents is in BCP 78 and BCP 79 📖
Copies of IPR disclosures made to the IETF Secretariat, plus any assurances of licenses to be made available, or the results of an attempt to get a general license or permission for implementers or users to use such proprietary rights, can be found in the IETF online IPR repository at http://www.ietf.org/ipr.
The IETF invites any interested party to bring to its attention any copyrights, patents or patent applications, or other proprietary rights that may cover technology needed to implement this standard. Send that info to the IETF at ietf-ipr@ietf.org 💌
Acknowledgement 🌷
Funding for the RFC Editor function is provided by the IETF Administrative Support Activity (IASA) 💖
📦 where this page comes from
- ietf: rfc4648 2006-10
- 💖 girlified by claude-haiku-5-5 on : a language model's rewrite of the original, under its terms