Home | History | Annotate | Line # | Download | only in ServiceRegistration 
      1 /* hash.c
      2  *
      3  * Copyright (c) 2019 Apple Computer, Inc. All rights reserved.
      4  *
      5  * Licensed under the Apache License, Version 2.0 (the "License");
      6  * you may not use this file except in compliance with the License.
      7  * You may obtain a copy of the License at
      8  *
      9  *     http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  *
     17  * DNS SIG(0) signature generation for DNSSD SRP using Security Framework.
     18  *
     19  * Functions required for loading, saving, and generating public/private keypairs, extracting the public key
     20  * into KEY RR data, and computing hashatures.
     21  */
     22 
     23 #include <stdio.h>
     24 #include <arpa/inet.h>
     25 #include <string.h>
     26 #include <stdlib.h>
     27 #include <unistd.h>
     28 #include <fcntl.h>
     29 #include <errno.h>
     30 
     31 #include "srp.h"
     32 #include "dns-msg.h"
     33 #define SRP_CRYPTO_MACOS_INTERNAL
     34 #include "srp-crypto.h"
     35 
     36 // Function to generate a signature given some data and a private key
     37 void
     38 srp_hmac_iov(hmac_key_t *key, uint8_t *output, size_t max, struct iovec *iov, int count)
     39 {
     40     // int digest_size = 0;
     41     // int i, line;
     42     (void)count;(void)iov;(void)output; (void)key; (void)max;
     43 #define KABLOOIE line = __LINE__ - 1; goto kablooie
     44 #if 0
     45     switch(key->algorithm) {
     46     case  SRP_HMAC_TYPE_SHA256:
     47         // digest_size = mbedtls_md_get_size(md_type);
     48         // break;
     49     default:
     50         ERROR("srp_hmac_iov: unsupported HMAC hash algorithm: %d", key->algorithm);
     51         return;
     52     }
     53     if (max < digest_size) {
     54         ERROR("srp_hmac_iov: not enough space in output buffer (%lu) for hash (%d).",
     55               (unsigned long)max, digest_size);
     56         return;
     57     }
     58 #endif
     59     // if ((status = mbedtls_md_hmac_starts(&ctx, key->secret, key->length)) != 0) {
     60     //     KABLOOIE;
     61     // }
     62 	// for (i = 0; i < count; i++) {
     63     //     if ((status = mbedtls_md_hmac_update(&ctx, iov[i].iov_base, iov[i].iov_len)) != 0) {
     64     //         KABLOOIE;
     65     //     }
     66 	// }
     67 	// if ((status = mbedtls_md_hmac_finish(&ctx, output)) != 0) {
     68     //     KABLOOIE;
     69 	// }
     70 }
     71 
     72 int
     73 srp_base64_parse(char *src, size_t *len_ret, uint8_t *buf, size_t buflen)
     74 {
     75     (void)src; (void)len_ret; (void)buf; (void)buflen;
     76 #if 0
     77     size_t slen = strlen(src);
     78     int ret = mbedtls_base64_decode(buf, buflen, len_ret, (const unsigned char *)src, slen);
     79     if (ret == MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL) {
     80         return ENOBUFS;
     81     } else if (ret == MBEDTLS_ERR_BASE64_INVALID_CHARACTER) {
     82         return EILSEQ;
     83     } else if (ret < 0) {
     84         return EINVAL;
     85     }
     86     return 0;
     87 #else
     88     return EINVAL;
     89 #endif
     90 }
     91 
     92 // Local Variables:
     93 // mode: C
     94 // tab-width: 4
     95 // c-file-style: "bsd"
     96 // c-basic-offset: 4
     97 // fill-column: 108
     98 // indent-tabs-mode: nil
     99 // End:
    100