lib/asn1/der_cmp.c

   1 /*
   2  * Copyright (c) 2003-2005 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * 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  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include "der_locl.h"
  35
  36 int ASN1CALL
  37 der_heim_oid_cmp(const heim_oid *p, const heim_oid *q)
  38 {
  39     int c;
  40
  41     if (p->length == q->length) {
  42         if (p->length == 0)
  43             return 0;
  44         return memcmp(p->components,
  45                       q->components,
  46                       p->length * sizeof(*p->components));
  47     }
  48     if (p->length < q->length) {
  49         if (p->length == 0 ||
  50             (c = memcmp(p->components,
  51                         q->components,
  52                         p->length * sizeof(*p->components))) == 0)
  53             return -1;
  54         return c;
  55     }
  56     if (q->length == 0 ||
  57         (c = memcmp(p->components,
  58                     q->components,
  59                     q->length * sizeof(*p->components))) == 0)
  60         return 1;
  61     return c;
  62 }
  63
  64 int ASN1CALL
  65 der_heim_octet_string_cmp(const heim_octet_string *p,
  66                           const heim_octet_string *q)
  67 {
  68     int c;
  69
  70     if (p->length == q->length) {
  71         if (p->length == 0)
  72             return 0;
  73         return memcmp(p->data, q->data, p->length);
  74     }
  75     if (p->length < q->length) {
  76         if (p->length == 0 ||
  77             (c = memcmp(p->data, q->data, p->length)) == 0)
  78             return -1;
  79         return c;
  80     }
  81     if (q->length == 0 ||
  82         (c = memcmp(p->data, q->data, q->length)) == 0)
  83         return 1;
  84     return c;
  85 }
  86
  87 int ASN1CALL
  88 der_printable_string_cmp(const heim_printable_string *p,
  89                          const heim_printable_string *q)
  90 {
  91     return der_heim_octet_string_cmp(p, q);
  92 }
  93
  94 int ASN1CALL
  95 der_ia5_string_cmp(const heim_ia5_string *p,
  96                    const heim_ia5_string *q)
  97 {
  98     return der_heim_octet_string_cmp(p, q);
  99 }
 100
 101 int ASN1CALL
 102 der_heim_bit_string_cmp(const heim_bit_string *p,
 103                         const heim_bit_string *q)
 104 {
 105     unsigned char pc, qc;
 106     size_t bits;
 107     int c = 0;
 108
 109     /* Compare prefix */
 110     if (p->length == 0 && q->length == 0)
 111         return 0;
 112     if (p->length > 7 && q->length > 7) {
 113         if (p->length < q->length)
 114             c = memcmp(p->data, q->data, p->length / 8);
 115         else
 116             c = memcmp(p->data, q->data, q->length / 8);
 117     }
 118     if (c)
 119         return c;
 120
 121     /* Prefixes are equal, c == 0 */
 122
 123     if (p->length == q->length && p->length % 8 == 0)
 124         return 0;
 125     if (p->length == 0 && q->length)
 126         return -1; /* No trailing bits of p to compare to corresponding bits of q */
 127     if (q->length == 0 && p->length)
 128         return  1; /* No trailing bits of q to compare to corresponding bits of p */
 129
 130     /* c == 0, lengths are not equal, both are at least 1 bit */
 131     pc = ((unsigned char *)p->data)[p->length / 8];
 132     qc = ((unsigned char *)q->data)[q->length / 8];
 133     if (p->length < q->length)
 134         bits = p->length % 8;
 135     else
 136         bits = q->length % 8;
 137
 138     if (bits > 0) {
 139         if ((pc & 0x80) == 0 && (qc & 0x80) != 0)
 140             return -1;
 141         if ((pc & 0x80) != 0 && (qc & 0x80) == 0)
 142             return 1;
 143     }
 144     if (bits > 1) {
 145         if ((pc & 0x40) == 0 && (qc & 0x40) != 0)
 146             return -1;
 147         if ((pc & 0x40) != 0 && (qc & 0x40) == 0)
 148             return 1;
 149     }
 150     if (bits > 2) {
 151         if ((pc & 0x20) == 0 && (qc & 0x20) != 0)
 152             return -1;
 153         if ((pc & 0x20) != 0 && (qc & 0x20) == 0)
 154             return 1;
 155     }
 156     if (bits > 3) {
 157         if ((pc & 0x10) == 0 && (qc & 0x10) != 0)
 158             return -1;
 159         if ((pc & 0x10) != 0 && (qc & 0x10) == 0)
 160             return 1;
 161     }
 162     if (bits > 4) {
 163         if ((pc & 0x08) == 0 && (qc & 0x08) != 0)
 164             return -1;
 165         if ((pc & 0x08) != 0 && (qc & 0x08) == 0)
 166             return 1;
 167     }
 168     if (bits > 5) {
 169         if ((pc & 0x04) == 0 && (qc & 0x04) != 0)
 170             return -1;
 171         if ((pc & 0x04) != 0 && (qc & 0x04) == 0)
 172             return 1;
 173     }
 174     if (bits > 6) {
 175         if ((pc & 0x02) == 0 && (qc & 0x02) != 0)
 176             return -1;
 177         if ((pc & 0x02) != 0 && (qc & 0x02) == 0)
 178             return 1;
 179     }
 180     /*
 181      * `bits' can't be 8.
 182      *
 183      * All leading `bits' bits of the tail of the shorter of `p' or `q' are
 184      * equal.
 185      */
 186     if (p->length < q->length)
 187         return -1;
 188     if (q->length < p->length)
 189         return  1;
 190     return 0;
 191 }
 192
 193 int ASN1CALL
 194 der_heim_integer_cmp(const heim_integer *p,
 195                      const heim_integer *q)
 196 {
 197     if (p->negative != q->negative)
 198         return q->negative - p->negative;
 199     if (p->length != q->length)
 200         return (int)(p->length - q->length);
 201     return memcmp(p->data, q->data, p->length);
 202 }
 203
 204 int ASN1CALL
 205 der_heim_bmp_string_cmp(const heim_bmp_string *p, const heim_bmp_string *q)
 206 {
 207     int c;
 208
 209     if (p->length == q->length) {
 210         if (p->length == 0)
 211             return 0;
 212         return memcmp(p->data, q->data, p->length * sizeof(q->data[0]));
 213     }
 214     if (p->length < q->length) {
 215         if (p->length == 0 ||
 216             (c = memcmp(p->data, q->data, p->length * sizeof(q->data[0]))) == 0)
 217             return -1;
 218         return c;
 219     }
 220     if (q->length == 0 ||
 221         (c = memcmp(p->data, q->data, q->length * sizeof(q->data[0]))) == 0)
 222         return 1;
 223     return c;
 224 }
 225
 226 int ASN1CALL
 227 der_heim_universal_string_cmp(const heim_universal_string *p,
 228                               const heim_universal_string *q)
 229 {
 230     int c;
 231
 232     if (p->length == q->length) {
 233         if (p->length == 0)
 234             return 0;
 235         return memcmp(p->data, q->data, p->length * sizeof(q->data[0]));
 236     }
 237     if (p->length < q->length) {
 238         if (p->length == 0 ||
 239             (c = memcmp(p->data, q->data, p->length * sizeof(q->data[0]))) == 0)
 240             return -1;
 241         return c;
 242     }
 243     if (q->length == 0 ||
 244         (c = memcmp(p->data, q->data, q->length * sizeof(q->data[0]))) == 0)
 245         return 1;
 246     return c;
 247 }