Use uint8_t vectors for WebCrypto data
[WebKit-https.git] / Source / WTF / wtf / text / Base64.h
1 /*
2  * Copyright (C) 2006 Alexey Proskuryakov <ap@webkit.org>
3  * Copyright (C) 2010 Patrick Gansterer <paroga@paroga.com>
4  * Copyright (C) 2013 Apple Inc. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
26  */
27
28 #ifndef Base64_h
29 #define Base64_h
30
31 #include <wtf/Vector.h>
32 #include <wtf/text/CString.h>
33 #include <wtf/text/WTFString.h>
34
35 namespace WTF {
36
37 enum Base64EncodePolicy {
38     Base64DoNotInsertLFs,
39     Base64InsertLFs,
40     Base64URLPolicy // No padding, no LFs.
41 };
42
43 enum Base64DecodePolicy {
44     Base64FailOnInvalidCharacterOrExcessPadding,
45     Base64FailOnInvalidCharacter,
46     Base64IgnoreWhitespace,
47     Base64IgnoreInvalidCharacters
48 };
49
50 class SignedOrUnsignedCharVectorAdapter {
51 public:
52     SignedOrUnsignedCharVectorAdapter(Vector<char>& vector) { m_vector.c = &vector; }
53     SignedOrUnsignedCharVectorAdapter(Vector<uint8_t>& vector) { m_vector.u = &vector; }
54
55     operator Vector<char>&() { return *m_vector.c; }
56     void clear() { m_vector.c->clear(); }
57
58 private:
59     union {
60         Vector<char>* c;
61         Vector<uint8_t>* u;
62     } m_vector;
63 };
64
65 class ConstSignedOrUnsignedCharVectorAdapter {
66 public:
67     ConstSignedOrUnsignedCharVectorAdapter(const Vector<char>& vector) { m_vector.c = &vector; }
68     ConstSignedOrUnsignedCharVectorAdapter(const Vector<uint8_t>& vector) { m_vector.u = &vector; }
69
70     operator const Vector<char>&() { return *m_vector.c; }
71     const char* data() const { return m_vector.c->data(); }
72     size_t size() const { return m_vector.c->size(); }
73
74 private:
75     union {
76         const Vector<char>* c;
77         const Vector<uint8_t>* u;
78     } m_vector;
79 };
80
81 WTF_EXPORT_PRIVATE void base64Encode(const void*, unsigned, Vector<char>&, Base64EncodePolicy = Base64DoNotInsertLFs);
82 WTF_EXPORT_PRIVATE void base64Encode(ConstSignedOrUnsignedCharVectorAdapter, Vector<char>&, Base64EncodePolicy = Base64DoNotInsertLFs);
83 WTF_EXPORT_PRIVATE void base64Encode(const CString&, Vector<char>&, Base64EncodePolicy = Base64DoNotInsertLFs);
84 WTF_EXPORT_PRIVATE String base64Encode(const void*, unsigned, Base64EncodePolicy = Base64DoNotInsertLFs);
85 WTF_EXPORT_PRIVATE String base64Encode(ConstSignedOrUnsignedCharVectorAdapter, Base64EncodePolicy = Base64DoNotInsertLFs);
86 WTF_EXPORT_PRIVATE String base64Encode(const CString&, Base64EncodePolicy = Base64DoNotInsertLFs);
87
88 WTF_EXPORT_PRIVATE bool base64Decode(const String&, SignedOrUnsignedCharVectorAdapter, Base64DecodePolicy = Base64FailOnInvalidCharacter);
89 WTF_EXPORT_PRIVATE bool base64Decode(const Vector<char>&, SignedOrUnsignedCharVectorAdapter, Base64DecodePolicy = Base64FailOnInvalidCharacter);
90 WTF_EXPORT_PRIVATE bool base64Decode(const char*, unsigned, SignedOrUnsignedCharVectorAdapter, Base64DecodePolicy = Base64FailOnInvalidCharacter);
91
92 inline void base64Encode(ConstSignedOrUnsignedCharVectorAdapter in, Vector<char>& out, Base64EncodePolicy policy)
93 {
94     base64Encode(in.data(), in.size(), out, policy);
95 }
96
97 inline void base64Encode(const CString& in, Vector<char>& out, Base64EncodePolicy policy)
98 {
99     base64Encode(in.data(), in.length(), out, policy);
100 }
101
102 inline String base64Encode(ConstSignedOrUnsignedCharVectorAdapter in, Base64EncodePolicy policy)
103 {
104     return base64Encode(in.data(), in.size(), policy);
105 }
106
107 inline String base64Encode(const CString& in, Base64EncodePolicy policy)
108 {
109     return base64Encode(in.data(), in.length(), policy);
110 }
111
112 // ======================================================================================
113 // All the same functions modified for base64url, as defined in RFC 4648.
114 // This format uses '-' and '_' instead of '+' and '/' respectively.
115 // ======================================================================================
116
117 WTF_EXPORT_PRIVATE void base64URLEncode(const void*, unsigned, Vector<char>&);
118 WTF_EXPORT_PRIVATE void base64URLEncode(ConstSignedOrUnsignedCharVectorAdapter, Vector<char>&);
119 WTF_EXPORT_PRIVATE void base64URLEncode(const CString&, Vector<char>&);
120 WTF_EXPORT_PRIVATE String base64URLEncode(const void*, unsigned);
121 WTF_EXPORT_PRIVATE String base64URLEncode(ConstSignedOrUnsignedCharVectorAdapter);
122 WTF_EXPORT_PRIVATE String base64URLEncode(const CString&);
123
124 WTF_EXPORT_PRIVATE bool base64URLDecode(const String&, SignedOrUnsignedCharVectorAdapter);
125 WTF_EXPORT_PRIVATE bool base64URLDecode(const Vector<char>&, SignedOrUnsignedCharVectorAdapter);
126 WTF_EXPORT_PRIVATE bool base64URLDecode(const char*, unsigned, SignedOrUnsignedCharVectorAdapter);
127
128 inline void base64URLEncode(ConstSignedOrUnsignedCharVectorAdapter in, Vector<char>& out)
129 {
130     base64URLEncode(in.data(), in.size(), out);
131 }
132
133 inline void base64URLEncode(const CString& in, Vector<char>& out)
134 {
135     base64URLEncode(in.data(), in.length(), out);
136 }
137
138 inline String base64URLEncode(ConstSignedOrUnsignedCharVectorAdapter in)
139 {
140     return base64URLEncode(in.data(), in.size());
141 }
142
143 inline String base64URLEncode(const CString& in)
144 {
145     return base64URLEncode(in.data(), in.length());
146 }
147
148 } // namespace WTF
149
150 using WTF::Base64EncodePolicy;
151 using WTF::Base64DoNotInsertLFs;
152 using WTF::Base64InsertLFs;
153 using WTF::Base64DecodePolicy;
154 using WTF::Base64FailOnInvalidCharacterOrExcessPadding;
155 using WTF::Base64FailOnInvalidCharacter;
156 using WTF::Base64IgnoreWhitespace;
157 using WTF::Base64IgnoreInvalidCharacters;
158 using WTF::base64Encode;
159 using WTF::base64Decode;
160 using WTF::base64URLDecode;
161
162 #endif // Base64_h