Libkleo

dn.cpp
1/*
2 dn.cpp
3
4 This file is part of libkleopatra, the KDE keymanagement library
5 SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
6 SPDX-FileCopyrightText: 2021 g10 Code GmbH
7 SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
8
9 DN parsing:
10 SPDX-FileCopyrightText: 2002 g10 Code GmbH
11 SPDX-FileCopyrightText: 2004 Klarälvdalens Datakonsult AB
12
13 SPDX-License-Identifier: GPL-2.0-or-later
14*/
15
16#include <config-libkleo.h>
17
18#include "dn.h"
19#include "libkleo_debug.h"
20
21#include "oidmap.h"
22
23#include <algorithm>
24
25#ifdef _MSC_VER
26#include <string.h>
27#define strcasecmp _stricmp
28#endif
29
30class Kleo::DN::Private
31{
32public:
33 Private()
34 : mRefCount(0)
35 {
36 }
37 Private(const Private &other)
38 : attributes(other.attributes)
39 , reorderedAttributes(other.reorderedAttributes)
40 , mRefCount(0)
41 {
42 }
43
44 int ref()
45 {
46 return ++mRefCount;
47 }
48
49 int unref()
50 {
51 if (--mRefCount <= 0) {
52 delete this;
53 return 0;
54 } else {
55 return mRefCount;
56 }
57 }
58
59 int refCount() const
60 {
61 return mRefCount;
62 }
63
64 DN::Attribute::List attributes;
65 DN::Attribute::List reorderedAttributes;
66
67private:
68 int mRefCount;
69};
70
71namespace
72{
73struct DnPair {
74 char *key;
75 char *value;
76};
77}
78
79// copied from CryptPlug and adapted to work on DN::Attribute::List:
80
81#define digitp(p) (*(p) >= '0' && *(p) <= '9')
82#define hexdigitp(a) (digitp(a) || (*(a) >= 'A' && *(a) <= 'F') || (*(a) >= 'a' && *(a) <= 'f'))
83#define xtoi_1(p) (*(p) <= '9' ? (*(p) - '0') : *(p) <= 'F' ? (*(p) - 'A' + 10) : (*(p) - 'a' + 10))
84#define xtoi_2(p) ((xtoi_1(p) * 16) + xtoi_1((p) + 1))
85
86static char *trim_trailing_spaces(char *string)
87{
88 char *p;
89 char *mark;
90
91 for (mark = nullptr, p = string; *p; p++) {
92 if (isspace(*p)) {
93 if (!mark) {
94 mark = p;
95 }
96 } else {
97 mark = nullptr;
98 }
99 }
100 if (mark) {
101 *mark = '\0';
102 }
103
104 return string;
105}
106
107/* Parse a DN and return an array-ized one. This is not a validating
108 parser and it does not support any old-stylish syntax; gpgme is
109 expected to return only rfc2253 compatible strings. */
110static const unsigned char *parse_dn_part(DnPair *array, const unsigned char *string)
111{
112 const unsigned char *s;
113 const unsigned char *s1;
114 size_t n;
115 char *p;
116
117 /* parse attributeType */
118 for (s = string + 1; *s && *s != '='; s++) {
119 ;
120 }
121 if (!*s) {
122 return nullptr; /* error */
123 }
124 n = s - string;
125 if (!n) {
126 return nullptr; /* empty key */
127 }
128 p = (char *)malloc(n + 1);
129
130 memcpy(p, string, n);
131 p[n] = 0;
132 trim_trailing_spaces((char *)p);
133 // map OIDs to their names:
134 if (const char *name = Kleo::attributeNameForOID(p)) {
135 free(p);
136 p = strdup(name);
137 }
138 array->key = p;
139 string = s + 1;
140
141 if (*string == '#') {
142 /* hexstring */
143 string++;
144 for (s = string; hexdigitp(s); s++)
145 ;
146 n = s - string;
147 if (!n || (n & 1)) {
148 return nullptr; /* empty or odd number of digits */
149 }
150 n /= 2;
151 array->value = p = (char *)malloc(n + 1);
152
153 for (s1 = string; n; s1 += 2, n--) {
154 *p++ = xtoi_2(s1);
155 }
156 *p = 0;
157 } else {
158 /* regular v3 quoted string */
159 for (n = 0, s = string; *s; s++) {
160 if (*s == '\\') {
161 /* pair */
162 s++;
163 if (*s == ',' || *s == '=' || *s == '+' || *s == '<' || *s == '>' || *s == '#' || *s == ';' || *s == '\\' || *s == '\"' || *s == ' ') {
164 n++;
165 } else if (hexdigitp(s) && hexdigitp(s + 1)) {
166 s++;
167 n++;
168 } else {
169 return nullptr; /* invalid escape sequence */
170 }
171 } else if (*s == '\"') {
172 return nullptr; /* invalid encoding */
173 } else if (*s == ',' || *s == '=' || *s == '+' || *s == '<' || *s == '>' || *s == '#' || *s == ';') {
174 break;
175 } else {
176 n++;
177 }
178 }
179
180 array->value = p = (char *)malloc(n + 1);
181
182 for (s = string; n; s++, n--) {
183 if (*s == '\\') {
184 s++;
185 if (hexdigitp(s)) {
186 *p++ = xtoi_2(s);
187 s++;
188 } else {
189 *p++ = *s;
190 }
191 } else {
192 *p++ = *s;
193 }
194 }
195 *p = 0;
196 }
197 return s;
198}
199
200/* Parse a DN and return an array-ized one. This is not a validating
201 parser and it does not support any old-stylish syntax; gpgme is
202 expected to return only rfc2253 compatible strings. */
203QT_WARNING_PUSH
204QT_WARNING_DISABLE_DEPRECATED
205static Kleo::DN::Attribute::List parse_dn(const unsigned char *string)
206{
207 QT_WARNING_POP
208 if (!string) {
209 QT_WARNING_PUSH
210 QT_WARNING_DISABLE_DEPRECATED
211 return QList<Kleo::DN::Attribute>();
212 QT_WARNING_POP
213 }
214
215 QT_WARNING_PUSH
216 QT_WARNING_DISABLE_DEPRECATED
217 QList<Kleo::DN::Attribute> result;
218 QT_WARNING_POP
219 while (*string) {
220 while (*string == ' ') {
221 string++;
222 }
223 if (!*string) {
224 break; /* ready */
225 }
226
227 DnPair pair = {nullptr, nullptr};
228 string = parse_dn_part(&pair, string);
229 if (!string) {
230 goto failure;
231 }
232 if (pair.key && pair.value) {
233 QT_WARNING_PUSH
234 QT_WARNING_DISABLE_DEPRECATED
235 result.push_back(Kleo::DN::Attribute(QString::fromUtf8(pair.key), QString::fromUtf8(pair.value)));
236 QT_WARNING_POP
237 }
238 free(pair.key);
239 free(pair.value);
240
241 while (*string == ' ') {
242 string++;
243 }
244 if (*string && *string != ',' && *string != ';' && *string != '+') {
245 goto failure; /* invalid delimiter */
246 }
247 if (*string) {
248 string++;
249 }
250 }
251 return result;
252
253failure:
254 QT_WARNING_PUSH
255 QT_WARNING_DISABLE_DEPRECATED
256 return QList<Kleo::DN::Attribute>();
257 QT_WARNING_POP
258}
259
260QT_WARNING_PUSH
261QT_WARNING_DISABLE_DEPRECATED
262static QList<Kleo::DN::Attribute> parse_dn(const QString &dn)
263{
264 QT_WARNING_POP
265 return parse_dn((const unsigned char *)dn.toUtf8().data());
266}
267
268static QString dn_escape(const QString &s)
269{
270 QString result;
271 for (int i = 0, end = s.length(); i != end; ++i) {
272 const QChar ch = s[i];
273 switch (ch.unicode()) {
274 case ',':
275 case '+':
276 case '"':
277 case '\\':
278 case '<':
279 case '>':
280 case ';':
281 result += QLatin1Char('\\');
282 // fall through
283 [[fallthrough]];
284 default:
285 result += ch;
286 }
287 }
288 return result;
289}
290
291QT_WARNING_PUSH
292QT_WARNING_DISABLE_DEPRECATED
293static QStringList listAttributes(const QList<Kleo::DN::Attribute> &dn)
294{
295 QT_WARNING_POP
296 QStringList result;
297 result.reserve(dn.size());
298 for (const auto &attribute : dn) {
299 if (!attribute.name().isEmpty() && !attribute.value().isEmpty()) {
300 result.push_back(attribute.name().trimmed() + QLatin1Char('=') + dn_escape(attribute.value().trimmed()));
301 }
302 }
303 return result;
304}
305
306QT_WARNING_PUSH
307QT_WARNING_DISABLE_DEPRECATED
308static QString serialise(const QList<Kleo::DN::Attribute> &dn, const QString &sep)
309{
310 QT_WARNING_POP
311 return listAttributes(dn).join(sep);
312}
313
314QT_WARNING_PUSH
315QT_WARNING_DISABLE_DEPRECATED
316static Kleo::DN::Attribute::List reorder_dn(const Kleo::DN::Attribute::List &dn)
317{
318 QT_WARNING_POP
319 const QStringList &attrOrder = Kleo::DNAttributes::order();
320
321 QT_WARNING_PUSH
322 QT_WARNING_DISABLE_DEPRECATED
323 Kleo::DN::Attribute::List unknownEntries;
324 Kleo::DN::Attribute::List result;
325 QT_WARNING_POP
326 unknownEntries.reserve(dn.size());
327 result.reserve(dn.size());
328
329 // find all unknown entries in their order of appearance
330 QT_WARNING_PUSH
331 QT_WARNING_DISABLE_DEPRECATED
332 for (Kleo::DN::const_iterator it = dn.begin(); it != dn.end(); ++it) {
333 QT_WARNING_POP
334 if (!attrOrder.contains((*it).name())) {
335 unknownEntries.push_back(*it);
336 }
337 }
338
339 // process the known attrs in the desired order
340 for (QStringList::const_iterator oit = attrOrder.begin(); oit != attrOrder.end(); ++oit) {
341 if (*oit == QLatin1StringView("_X_")) {
342 // insert the unknown attrs
343 std::copy(unknownEntries.begin(), unknownEntries.end(), std::back_inserter(result));
344 unknownEntries.clear(); // don't produce dup's
345 } else {
346 QT_WARNING_PUSH
347 QT_WARNING_DISABLE_DEPRECATED
348 for (Kleo::DN::const_iterator dnit = dn.begin(); dnit != dn.end(); ++dnit) {
349 QT_WARNING_POP
350 if ((*dnit).name() == *oit) {
351 result.push_back(*dnit);
352 }
353 }
354 }
355 }
356
357 return result;
358}
359
360//
361//
362// class DN
363//
364//
365
366Kleo::DN::DN()
367{
368 d = new Private();
369 d->ref();
370}
371
372Kleo::DN::DN(const QString &dn)
373{
374 d = new Private();
375 d->ref();
376 d->attributes = parse_dn(dn);
377}
378
379Kleo::DN::DN(const char *utf8DN)
380{
381 d = new Private();
382 d->ref();
383 if (utf8DN) {
384 d->attributes = parse_dn((const unsigned char *)utf8DN);
385 }
386}
387
388Kleo::DN::DN(const DN &other)
389 : d(other.d)
390{
391 if (d) {
392 d->ref();
393 }
394}
395
396Kleo::DN::~DN()
397{
398 if (d) {
399 d->unref();
400 }
401}
402
403QT_WARNING_PUSH
404QT_WARNING_DISABLE_DEPRECATED
405const Kleo::DN &Kleo::DN::operator=(const DN &that)
406{
407 QT_WARNING_POP
408 if (this->d == that.d) {
409 return *this;
410 }
411
412 if (that.d) {
413 that.d->ref();
414 }
415 if (this->d) {
416 this->d->unref();
417 }
418
419 this->d = that.d;
420
421 return *this;
422}
423
424QString Kleo::DN::prettyDN() const
425{
426 if (!d) {
427 return QString();
428 }
429 if (d->reorderedAttributes.empty()) {
430 d->reorderedAttributes = reorder_dn(d->attributes);
431 }
432 return serialise(d->reorderedAttributes, QStringLiteral(","));
433}
434
435QStringList Kleo::DN::prettyAttributes() const
436{
437 if (!d) {
438 return {};
439 }
440
441 if (d->reorderedAttributes.empty()) {
442 d->reorderedAttributes = reorder_dn(d->attributes);
443 }
444 return listAttributes(d->reorderedAttributes);
445}
446
447QString Kleo::DN::dn() const
448{
449 return d ? serialise(d->attributes, QStringLiteral(",")) : QString();
450}
451
452QString Kleo::DN::dn(const QString &sep) const
453{
454 return d ? serialise(d->attributes, sep) : QString();
455}
456
457// static
458QString Kleo::DN::escape(const QString &value)
459{
460 return dn_escape(value);
461}
462
463void Kleo::DN::detach()
464{
465 if (!d) {
466 d = new Kleo::DN::Private();
467 d->ref();
468 } else if (d->refCount() > 1) {
469 Kleo::DN::Private *d_save = d;
470 d = new Kleo::DN::Private(*d);
471 d->ref();
472 d_save->unref();
473 }
474}
475
476void Kleo::DN::append(const Attribute &attr)
477{
478 detach();
479 d->attributes.push_back(attr);
480 d->reorderedAttributes.clear();
481}
482
483QString Kleo::DN::operator[](const QString &attr) const
484{
485 if (!d) {
486 return QString();
487 }
488 const QString attrUpper = attr.toUpper();
489 for (QList<Attribute>::const_iterator it = d->attributes.constBegin(); it != d->attributes.constEnd(); ++it) {
490 if ((*it).name() == attrUpper) {
491 return (*it).value();
492 }
493 }
494 return QString();
495}
496
497QT_WARNING_PUSH
498QT_WARNING_DISABLE_DEPRECATED
499static QList<Kleo::DN::Attribute> empty;
500QT_WARNING_POP
501
502QT_WARNING_PUSH
503QT_WARNING_DISABLE_DEPRECATED
504Kleo::DN::const_iterator Kleo::DN::begin() const
505{
506 QT_WARNING_POP
507 return d ? d->attributes.constBegin() : empty.constBegin();
508}
509
510QT_WARNING_PUSH
511QT_WARNING_DISABLE_DEPRECATED
512Kleo::DN::const_iterator Kleo::DN::end() const
513{
514 QT_WARNING_POP
515 return d ? d->attributes.constEnd() : empty.constEnd();
516}
Kleo::DN
DN parser and reorderer.
Definition dn.h:29
Kleo::DN::escape
static QString escape(const QString &value)
Definition dn.cpp:458
Kleo::DN::prettyDN
QString prettyDN() const
Definition dn.cpp:424
Kleo::DN::dn
QString dn() const
Definition dn.cpp:447
Kleo::DN::prettyAttributes
QStringList prettyAttributes() const
Returns the non-empty attributes formatted as {NAME=value} and reordered according to the settings in...
Definition dn.cpp:435
QByteArray::data
char * data()
QChar::unicode
char16_t & unicode()
QList::begin
iterator begin()
QList::end
iterator end()
QList::push_back
void push_back(parameter_type value)
QList::reserve
void reserve(qsizetype size)
QList::size
qsizetype size() const const
QString::fromUtf8
QString fromUtf8(QByteArrayView str)
QString::length
qsizetype length() const const
QString::reserve
void reserve(qsizetype size)
QString::toUpper
QString toUpper() const const
QString::toUtf8
QByteArray toUtf8() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 25 2025 11:49:02 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.