1*472cd20dSToomas Soome /*
2*472cd20dSToomas Soome * Copyright (c) 2002-2019 Apple Inc. All rights reserved.
33b436d06SToomas Soome * Copyright (c) 2016 by Delphix. All rights reserved.
44b22b933Srs *
54b22b933Srs * Licensed under the Apache License, Version 2.0 (the "License");
64b22b933Srs * you may not use this file except in compliance with the License.
74b22b933Srs * You may obtain a copy of the License at
85ffb0c9bSToomas Soome *
94b22b933Srs * http://www.apache.org/licenses/LICENSE-2.0
105ffb0c9bSToomas Soome *
114b22b933Srs * Unless required by applicable law or agreed to in writing, software
124b22b933Srs * distributed under the License is distributed on an "AS IS" BASIS,
134b22b933Srs * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
144b22b933Srs * See the License for the specific language governing permissions and
154b22b933Srs * limitations under the License.
165ffb0c9bSToomas Soome */
174b22b933Srs
184b22b933Srs #ifdef __cplusplus
194b22b933Srs extern "C" {
204b22b933Srs #endif
214b22b933Srs
224b22b933Srs #include "mDNSEmbeddedAPI.h"
234b22b933Srs #include "DNSCommon.h"
244b22b933Srs
254b22b933Srs // Disable certain benign warnings with Microsoft compilers
265ffb0c9bSToomas Soome #if (defined(_MSC_VER))
275ffb0c9bSToomas Soome // Disable "conditional expression is constant" warning for debug macros.
285ffb0c9bSToomas Soome // Otherwise, this generates warnings for the perfectly natural construct "while(1)"
295ffb0c9bSToomas Soome // If someone knows a variant way of writing "while(1)" that doesn't generate warning messages, please let us know
305ffb0c9bSToomas Soome #pragma warning(disable:4127)
315ffb0c9bSToomas Soome #endif
325ffb0c9bSToomas Soome
335ffb0c9bSToomas Soome
345ffb0c9bSToomas Soome // ***************************************************************************
355ffb0c9bSToomas Soome #if COMPILER_LIKES_PRAGMA_MARK
365ffb0c9bSToomas Soome #pragma mark - Byte Swapping Functions
374b22b933Srs #endif
384b22b933Srs
NToH16(mDNSu8 * bytes)395ffb0c9bSToomas Soome mDNSlocal mDNSu16 NToH16(mDNSu8 * bytes)
405ffb0c9bSToomas Soome {
415ffb0c9bSToomas Soome return (mDNSu16)((mDNSu16)bytes[0] << 8 | (mDNSu16)bytes[1]);
425ffb0c9bSToomas Soome }
435ffb0c9bSToomas Soome
NToH32(mDNSu8 * bytes)445ffb0c9bSToomas Soome mDNSlocal mDNSu32 NToH32(mDNSu8 * bytes)
455ffb0c9bSToomas Soome {
465ffb0c9bSToomas Soome return (mDNSu32)((mDNSu32) bytes[0] << 24 | (mDNSu32) bytes[1] << 16 | (mDNSu32) bytes[2] << 8 | (mDNSu32)bytes[3]);
475ffb0c9bSToomas Soome }
485ffb0c9bSToomas Soome
495ffb0c9bSToomas Soome // ***************************************************************************
504b22b933Srs #if COMPILER_LIKES_PRAGMA_MARK
514b22b933Srs #pragma mark - MD5 Hash Functions
524b22b933Srs #endif
534b22b933Srs
544b22b933Srs
554b22b933Srs /* The source for the has is derived CommonCrypto files CommonDigest.h, md32_common.h, md5_locl.h, md5_locl.h, and openssl/md5.h.
564b22b933Srs * The following changes have been made to the original sources:
574b22b933Srs * replaced CC_LONG w/ mDNSu32
584b22b933Srs * replaced CC_MD5* with MD5*
594b22b933Srs * replaced CC_LONG w/ mDNSu32, removed conditional #defines from md5.h
604b22b933Srs * removed extern decls for MD5_Init/Update/Final from CommonDigest.h
614b22b933Srs * removed APPLE_COMMON_DIGEST specific #defines from md5_locl.h
624b22b933Srs *
634b22b933Srs * Note: machine archetecure specific conditionals from the original sources are turned off, but are left in the code
644b22b933Srs * to aid in platform-specific optimizations and debugging.
654b22b933Srs * Sources originally distributed under the following license headers:
665ffb0c9bSToomas Soome * CommonDigest.h - APSL
675ffb0c9bSToomas Soome *
684b22b933Srs * md32_Common.h
694b22b933Srs * ====================================================================
704b22b933Srs * Copyright (c) 1999-2002 The OpenSSL Project. All rights reserved.
714b22b933Srs *
724b22b933Srs * Redistribution and use in source and binary forms, with or without
734b22b933Srs * modification, are permitted provided that the following conditions
744b22b933Srs * are met:
754b22b933Srs *
764b22b933Srs * 1. Redistributions of source code must retain the above copyright
775ffb0c9bSToomas Soome * notice, this list of conditions and the following disclaimer.
784b22b933Srs *
794b22b933Srs * 2. Redistributions in binary form must reproduce the above copyright
804b22b933Srs * notice, this list of conditions and the following disclaimer in
814b22b933Srs * the documentation and/or other materials provided with the
824b22b933Srs * distribution.
834b22b933Srs *
844b22b933Srs * 3. All advertising materials mentioning features or use of this
854b22b933Srs * software must display the following acknowledgment:
864b22b933Srs * "This product includes software developed by the OpenSSL Project
874b22b933Srs * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
884b22b933Srs *
894b22b933Srs * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
904b22b933Srs * endorse or promote products derived from this software without
914b22b933Srs * prior written permission. For written permission, please contact
924b22b933Srs * licensing@OpenSSL.org.
934b22b933Srs *
944b22b933Srs * 5. Products derived from this software may not be called "OpenSSL"
954b22b933Srs * nor may "OpenSSL" appear in their names without prior written
964b22b933Srs * permission of the OpenSSL Project.
974b22b933Srs *
984b22b933Srs * 6. Redistributions of any form whatsoever must retain the following
994b22b933Srs * acknowledgment:
1004b22b933Srs * "This product includes software developed by the OpenSSL Project
1014b22b933Srs * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
1024b22b933Srs *
1034b22b933Srs * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
1044b22b933Srs * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1054b22b933Srs * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1064b22b933Srs * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
1074b22b933Srs * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
1084b22b933Srs * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
1094b22b933Srs * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
1104b22b933Srs * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1114b22b933Srs * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
1124b22b933Srs * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1134b22b933Srs * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
1144b22b933Srs * OF THE POSSIBILITY OF SUCH DAMAGE.
1154b22b933Srs *
1164b22b933Srs *
1174b22b933Srs * md5_dgst.c, md5_locl.h
1184b22b933Srs * ====================================================================
1194b22b933Srs *
1204b22b933Srs * This product includes cryptographic software written by Eric Young
1214b22b933Srs * (eay@cryptsoft.com). This product includes software written by Tim
1224b22b933Srs * Hudson (tjh@cryptsoft.com).
1234b22b933Srs *
1244b22b933Srs * Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
1254b22b933Srs * All rights reserved.
1264b22b933Srs *
1274b22b933Srs * This package is an SSL implementation written
1284b22b933Srs * by Eric Young (eay@cryptsoft.com).
1294b22b933Srs * The implementation was written so as to conform with Netscapes SSL.
1305ffb0c9bSToomas Soome *
1314b22b933Srs * This library is free for commercial and non-commercial use as long as
1324b22b933Srs * the following conditions are aheared to. The following conditions
1334b22b933Srs * apply to all code found in this distribution, be it the RC4, RSA,
1344b22b933Srs * lhash, DES, etc., code; not just the SSL code. The SSL documentation
1354b22b933Srs * included with this distribution is covered by the same copyright terms
1364b22b933Srs * except that the holder is Tim Hudson (tjh@cryptsoft.com).
1375ffb0c9bSToomas Soome *
1384b22b933Srs * Copyright remains Eric Young's, and as such any Copyright notices in
1394b22b933Srs * the code are not to be removed.
1404b22b933Srs * If this package is used in a product, Eric Young should be given attribution
1414b22b933Srs * as the author of the parts of the library used.
1424b22b933Srs * This can be in the form of a textual message at program startup or
1434b22b933Srs * in documentation (online or textual) provided with the package.
1445ffb0c9bSToomas Soome *
1454b22b933Srs * Redistribution and use in source and binary forms, with or without
1464b22b933Srs * modification, are permitted provided that the following conditions
1474b22b933Srs * are met:
1484b22b933Srs * 1. Redistributions of source code must retain the copyright
1494b22b933Srs * notice, this list of conditions and the following disclaimer.
1504b22b933Srs * 2. Redistributions in binary form must reproduce the above copyright
1514b22b933Srs * notice, this list of conditions and the following disclaimer in the
1524b22b933Srs * documentation and/or other materials provided with the distribution.
1534b22b933Srs * 3. All advertising materials mentioning features or use of this software
1544b22b933Srs * must display the following acknowledgement:
1554b22b933Srs * "This product includes cryptographic software written by
1564b22b933Srs * Eric Young (eay@cryptsoft.com)"
1574b22b933Srs * The word 'cryptographic' can be left out if the rouines from the library
1584b22b933Srs * being used are not cryptographic related :-).
1595ffb0c9bSToomas Soome * 4. If you include any Windows specific code (or a derivative thereof) from
1604b22b933Srs * the apps directory (application code) you must include an acknowledgement:
1614b22b933Srs * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
1625ffb0c9bSToomas Soome *
1634b22b933Srs * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
1644b22b933Srs * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1654b22b933Srs * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1664b22b933Srs * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1674b22b933Srs * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1684b22b933Srs * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1694b22b933Srs * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1704b22b933Srs * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1714b22b933Srs * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1724b22b933Srs * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1734b22b933Srs * SUCH DAMAGE.
1745ffb0c9bSToomas Soome *
1754b22b933Srs * The licence and distribution terms for any publically available version or
1764b22b933Srs * derivative of this code cannot be changed. i.e. this code cannot simply be
1774b22b933Srs * copied and put under another distribution licence
1784b22b933Srs * [including the GNU Public Licence.]
1794b22b933Srs *
1804b22b933Srs */
1814b22b933Srs
1824b22b933Srs //from CommonDigest.h
1834b22b933Srs
1844b22b933Srs
1854b22b933Srs
1864b22b933Srs // from openssl/md5.h
1874b22b933Srs
1885ffb0c9bSToomas Soome #define MD5_CBLOCK 64
1895ffb0c9bSToomas Soome #define MD5_LBLOCK (MD5_CBLOCK/4)
1904b22b933Srs #define MD5_DIGEST_LENGTH 16
1914b22b933Srs
1924b22b933Srs void MD5_Transform(MD5_CTX *c, const unsigned char *b);
1934b22b933Srs
1944b22b933Srs // From md5_locl.h
1954b22b933Srs
1964b22b933Srs #ifndef MD5_LONG_LOG2
1974b22b933Srs #define MD5_LONG_LOG2 2 /* default to 32 bits */
1984b22b933Srs #endif
1994b22b933Srs
2004b22b933Srs #ifdef MD5_ASM
2014b22b933Srs # if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
2024b22b933Srs # define md5_block_host_order md5_block_asm_host_order
2034b22b933Srs # elif defined(__sparc) && defined(OPENSSL_SYS_ULTRASPARC)
2045ffb0c9bSToomas Soome void md5_block_asm_data_order_aligned (MD5_CTX *c, const mDNSu32 *p,int num);
2054b22b933Srs # define HASH_BLOCK_DATA_ORDER_ALIGNED md5_block_asm_data_order_aligned
2064b22b933Srs # endif
2074b22b933Srs #endif
2084b22b933Srs
2094b22b933Srs void md5_block_host_order (MD5_CTX *c, const void *p,int num);
2104b22b933Srs void md5_block_data_order (MD5_CTX *c, const void *p,int num);
2114b22b933Srs
2124b22b933Srs #if defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(__INTEL__)
2134b22b933Srs /*
2144b22b933Srs * *_block_host_order is expected to handle aligned data while
2154b22b933Srs * *_block_data_order - unaligned. As algorithm and host (x86)
2164b22b933Srs * are in this case of the same "endianness" these two are
2174b22b933Srs * otherwise indistinguishable. But normally you don't want to
2184b22b933Srs * call the same function because unaligned access in places
2194b22b933Srs * where alignment is expected is usually a "Bad Thing". Indeed,
2204b22b933Srs * on RISCs you get punished with BUS ERROR signal or *severe*
2214b22b933Srs * performance degradation. Intel CPUs are in turn perfectly
2224b22b933Srs * capable of loading unaligned data without such drastic side
2234b22b933Srs * effect. Yes, they say it's slower than aligned load, but no
2244b22b933Srs * exception is generated and therefore performance degradation
2254b22b933Srs * is *incomparable* with RISCs. What we should weight here is
2264b22b933Srs * costs of unaligned access against costs of aligning data.
2274b22b933Srs * According to my measurements allowing unaligned access results
2284b22b933Srs * in ~9% performance improvement on Pentium II operating at
2294b22b933Srs * 266MHz. I won't be surprised if the difference will be higher
2304b22b933Srs * on faster systems:-)
2314b22b933Srs *
2324b22b933Srs * <appro@fy.chalmers.se>
2334b22b933Srs */
2344b22b933Srs #define md5_block_data_order md5_block_host_order
2354b22b933Srs #endif
2364b22b933Srs
2374b22b933Srs #define DATA_ORDER_IS_LITTLE_ENDIAN
2384b22b933Srs
2395ffb0c9bSToomas Soome #define HASH_LONG mDNSu32
2405ffb0c9bSToomas Soome #define HASH_LONG_LOG2 MD5_LONG_LOG2
2415ffb0c9bSToomas Soome #define HASH_CTX MD5_CTX
2425ffb0c9bSToomas Soome #define HASH_CBLOCK MD5_CBLOCK
2435ffb0c9bSToomas Soome #define HASH_LBLOCK MD5_LBLOCK
2445ffb0c9bSToomas Soome
2455ffb0c9bSToomas Soome #define HASH_UPDATE MD5_Update
2465ffb0c9bSToomas Soome #define HASH_TRANSFORM MD5_Transform
2475ffb0c9bSToomas Soome #define HASH_FINAL MD5_Final
2485ffb0c9bSToomas Soome
2495ffb0c9bSToomas Soome #define HASH_MAKE_STRING(c,s) do { \
2505ffb0c9bSToomas Soome unsigned long ll; \
2515ffb0c9bSToomas Soome ll=(c)->A; HOST_l2c(ll,(s)); \
2525ffb0c9bSToomas Soome ll=(c)->B; HOST_l2c(ll,(s)); \
2535ffb0c9bSToomas Soome ll=(c)->C; HOST_l2c(ll,(s)); \
2545ffb0c9bSToomas Soome ll=(c)->D; HOST_l2c(ll,(s)); \
2555ffb0c9bSToomas Soome } while (0)
2565ffb0c9bSToomas Soome #define HASH_BLOCK_HOST_ORDER md5_block_host_order
2574b22b933Srs #if !defined(L_ENDIAN) || defined(md5_block_data_order)
2585ffb0c9bSToomas Soome #define HASH_BLOCK_DATA_ORDER md5_block_data_order
2594b22b933Srs /*
2604b22b933Srs * Little-endians (Intel and Alpha) feel better without this.
2614b22b933Srs * It looks like memcpy does better job than generic
2624b22b933Srs * md5_block_data_order on copying-n-aligning input data.
2634b22b933Srs * But frankly speaking I didn't expect such result on Alpha.
2644b22b933Srs * On the other hand I've got this with egcs-1.0.2 and if
2654b22b933Srs * program is compiled with another (better?) compiler it
2664b22b933Srs * might turn out other way around.
2674b22b933Srs *
2684b22b933Srs * <appro@fy.chalmers.se>
2694b22b933Srs */
2704b22b933Srs #endif
2714b22b933Srs
2724b22b933Srs
2734b22b933Srs // from md32_common.h
2744b22b933Srs
2754b22b933Srs /*
2764b22b933Srs * This is a generic 32 bit "collector" for message digest algorithms.
2774b22b933Srs * Whenever needed it collects input character stream into chunks of
2784b22b933Srs * 32 bit values and invokes a block function that performs actual hash
2794b22b933Srs * calculations.
2804b22b933Srs *
2814b22b933Srs * Porting guide.
2824b22b933Srs *
2834b22b933Srs * Obligatory macros:
2844b22b933Srs *
2854b22b933Srs * DATA_ORDER_IS_BIG_ENDIAN or DATA_ORDER_IS_LITTLE_ENDIAN
2864b22b933Srs * this macro defines byte order of input stream.
2874b22b933Srs * HASH_CBLOCK
2884b22b933Srs * size of a unit chunk HASH_BLOCK operates on.
2894b22b933Srs * HASH_LONG
2904b22b933Srs * has to be at lest 32 bit wide, if it's wider, then
2914b22b933Srs * HASH_LONG_LOG2 *has to* be defined along
2924b22b933Srs * HASH_CTX
2934b22b933Srs * context structure that at least contains following
2944b22b933Srs * members:
2954b22b933Srs * typedef struct {
2964b22b933Srs * ...
2974b22b933Srs * HASH_LONG Nl,Nh;
2984b22b933Srs * HASH_LONG data[HASH_LBLOCK];
2994b22b933Srs * int num;
3004b22b933Srs * ...
3014b22b933Srs * } HASH_CTX;
3024b22b933Srs * HASH_UPDATE
3034b22b933Srs * name of "Update" function, implemented here.
3044b22b933Srs * HASH_TRANSFORM
3054b22b933Srs * name of "Transform" function, implemented here.
3064b22b933Srs * HASH_FINAL
3074b22b933Srs * name of "Final" function, implemented here.
3084b22b933Srs * HASH_BLOCK_HOST_ORDER
3094b22b933Srs * name of "block" function treating *aligned* input message
3104b22b933Srs * in host byte order, implemented externally.
3114b22b933Srs * HASH_BLOCK_DATA_ORDER
3124b22b933Srs * name of "block" function treating *unaligned* input message
3134b22b933Srs * in original (data) byte order, implemented externally (it
3144b22b933Srs * actually is optional if data and host are of the same
3154b22b933Srs * "endianess").
3164b22b933Srs * HASH_MAKE_STRING
3174b22b933Srs * macro convering context variables to an ASCII hash string.
3184b22b933Srs *
3194b22b933Srs * Optional macros:
3204b22b933Srs *
3214b22b933Srs * B_ENDIAN or L_ENDIAN
3224b22b933Srs * defines host byte-order.
3234b22b933Srs * HASH_LONG_LOG2
3244b22b933Srs * defaults to 2 if not states otherwise.
3254b22b933Srs * HASH_LBLOCK
3264b22b933Srs * assumed to be HASH_CBLOCK/4 if not stated otherwise.
3274b22b933Srs * HASH_BLOCK_DATA_ORDER_ALIGNED
3284b22b933Srs * alternative "block" function capable of treating
3294b22b933Srs * aligned input message in original (data) order,
3304b22b933Srs * implemented externally.
3314b22b933Srs *
3324b22b933Srs * MD5 example:
3334b22b933Srs *
3344b22b933Srs * #define DATA_ORDER_IS_LITTLE_ENDIAN
3354b22b933Srs *
3364b22b933Srs * #define HASH_LONG mDNSu32
3374b22b933Srs * #define HASH_LONG_LOG2 mDNSu32_LOG2
3384b22b933Srs * #define HASH_CTX MD5_CTX
3394b22b933Srs * #define HASH_CBLOCK MD5_CBLOCK
3404b22b933Srs * #define HASH_LBLOCK MD5_LBLOCK
3414b22b933Srs * #define HASH_UPDATE MD5_Update
3424b22b933Srs * #define HASH_TRANSFORM MD5_Transform
3434b22b933Srs * #define HASH_FINAL MD5_Final
3444b22b933Srs * #define HASH_BLOCK_HOST_ORDER md5_block_host_order
3454b22b933Srs * #define HASH_BLOCK_DATA_ORDER md5_block_data_order
3464b22b933Srs *
3474b22b933Srs * <appro@fy.chalmers.se>
3484b22b933Srs */
3494b22b933Srs
3504b22b933Srs #if !defined(DATA_ORDER_IS_BIG_ENDIAN) && !defined(DATA_ORDER_IS_LITTLE_ENDIAN)
3514b22b933Srs #error "DATA_ORDER must be defined!"
3524b22b933Srs #endif
3534b22b933Srs
3544b22b933Srs #ifndef HASH_CBLOCK
3554b22b933Srs #error "HASH_CBLOCK must be defined!"
3564b22b933Srs #endif
3574b22b933Srs #ifndef HASH_LONG
3584b22b933Srs #error "HASH_LONG must be defined!"
3594b22b933Srs #endif
3604b22b933Srs #ifndef HASH_CTX
3614b22b933Srs #error "HASH_CTX must be defined!"
3624b22b933Srs #endif
3634b22b933Srs
3644b22b933Srs #ifndef HASH_UPDATE
3654b22b933Srs #error "HASH_UPDATE must be defined!"
3664b22b933Srs #endif
3674b22b933Srs #ifndef HASH_TRANSFORM
3684b22b933Srs #error "HASH_TRANSFORM must be defined!"
3694b22b933Srs #endif
3704b22b933Srs #ifndef HASH_FINAL
3714b22b933Srs #error "HASH_FINAL must be defined!"
3724b22b933Srs #endif
3734b22b933Srs
3744b22b933Srs #ifndef HASH_BLOCK_HOST_ORDER
3754b22b933Srs #error "HASH_BLOCK_HOST_ORDER must be defined!"
3764b22b933Srs #endif
3774b22b933Srs
3784b22b933Srs #if 0
3794b22b933Srs /*
3804b22b933Srs * Moved below as it's required only if HASH_BLOCK_DATA_ORDER_ALIGNED
3814b22b933Srs * isn't defined.
3824b22b933Srs */
3834b22b933Srs #ifndef HASH_BLOCK_DATA_ORDER
3844b22b933Srs #error "HASH_BLOCK_DATA_ORDER must be defined!"
3854b22b933Srs #endif
3864b22b933Srs #endif
3874b22b933Srs
3884b22b933Srs #ifndef HASH_LBLOCK
3895ffb0c9bSToomas Soome #define HASH_LBLOCK (HASH_CBLOCK/4)
3904b22b933Srs #endif
3914b22b933Srs
3924b22b933Srs #ifndef HASH_LONG_LOG2
3935ffb0c9bSToomas Soome #define HASH_LONG_LOG2 2
3944b22b933Srs #endif
3954b22b933Srs
3964b22b933Srs /*
3974b22b933Srs * Engage compiler specific rotate intrinsic function if available.
3984b22b933Srs */
3994b22b933Srs #undef ROTATE
4004b22b933Srs #ifndef PEDANTIC
4014b22b933Srs # if 0 /* defined(_MSC_VER) */
4025ffb0c9bSToomas Soome # define ROTATE(a,n) _lrotl(a,n)
4034b22b933Srs # elif defined(__MWERKS__)
4044b22b933Srs # if defined(__POWERPC__)
4055ffb0c9bSToomas Soome # define ROTATE(a,n) (unsigned MD32_REG_T)__rlwinm((int)a,n,0,31)
4064b22b933Srs # elif defined(__MC68K__)
4075ffb0c9bSToomas Soome /* Motorola specific tweak. <appro@fy.chalmers.se> */
4085ffb0c9bSToomas Soome # define ROTATE(a,n) (n<24 ? __rol(a,n) : __ror(a,32-n))
4094b22b933Srs # else
4105ffb0c9bSToomas Soome # define ROTATE(a,n) __rol(a,n)
4114b22b933Srs # endif
4124b22b933Srs # elif defined(__GNUC__) && __GNUC__>=2 && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
4135ffb0c9bSToomas Soome /*
4145ffb0c9bSToomas Soome * Some GNU C inline assembler templates. Note that these are
4155ffb0c9bSToomas Soome * rotates by *constant* number of bits! But that's exactly
4165ffb0c9bSToomas Soome * what we need here...
4175ffb0c9bSToomas Soome *
4185ffb0c9bSToomas Soome * <appro@fy.chalmers.se>
4195ffb0c9bSToomas Soome */
4205ffb0c9bSToomas Soome /*
4215ffb0c9bSToomas Soome * LLVM is more strict about compatibility of types between input & output constraints,
4225ffb0c9bSToomas Soome * but we want these to be rotations of 32 bits, not 64, so we explicitly drop the
4235ffb0c9bSToomas Soome * most significant bytes by casting to an unsigned int.
4245ffb0c9bSToomas Soome */
4254b22b933Srs # if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)
4265ffb0c9bSToomas Soome # define ROTATE(a,n) ({ register unsigned int ret; \
4275ffb0c9bSToomas Soome asm ( \
4285ffb0c9bSToomas Soome "roll %1,%0" \
4295ffb0c9bSToomas Soome : "=r" (ret) \
4305ffb0c9bSToomas Soome : "I" (n), "0" ((unsigned int)a) \
4315ffb0c9bSToomas Soome : "cc"); \
4325ffb0c9bSToomas Soome ret; \
4335ffb0c9bSToomas Soome })
4344b22b933Srs # elif defined(__powerpc) || defined(__ppc)
4355ffb0c9bSToomas Soome # define ROTATE(a,n) ({ register unsigned int ret; \
4365ffb0c9bSToomas Soome asm ( \
4375ffb0c9bSToomas Soome "rlwinm %0,%1,%2,0,31" \
4385ffb0c9bSToomas Soome : "=r" (ret) \
4395ffb0c9bSToomas Soome : "r" (a), "I" (n)); \
4405ffb0c9bSToomas Soome ret; \
4415ffb0c9bSToomas Soome })
4424b22b933Srs # endif
4434b22b933Srs # endif
4444b22b933Srs
4454b22b933Srs /*
4464b22b933Srs * Engage compiler specific "fetch in reverse byte order"
4474b22b933Srs * intrinsic function if available.
4484b22b933Srs */
4494b22b933Srs # if defined(__GNUC__) && __GNUC__>=2 && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
4505ffb0c9bSToomas Soome /* some GNU C inline assembler templates by <appro@fy.chalmers.se> */
4514b22b933Srs # if (defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)) && !defined(I386_ONLY)
4525ffb0c9bSToomas Soome # define BE_FETCH32(a) ({ register unsigned int l=(a); \
4535ffb0c9bSToomas Soome asm ( \
4545ffb0c9bSToomas Soome "bswapl %0" \
4555ffb0c9bSToomas Soome : "=r" (l) : "0" (l)); \
4565ffb0c9bSToomas Soome l; \
4575ffb0c9bSToomas Soome })
4584b22b933Srs # elif defined(__powerpc)
4595ffb0c9bSToomas Soome # define LE_FETCH32(a) ({ register unsigned int l; \
4605ffb0c9bSToomas Soome asm ( \
4615ffb0c9bSToomas Soome "lwbrx %0,0,%1" \
4625ffb0c9bSToomas Soome : "=r" (l) \
4635ffb0c9bSToomas Soome : "r" (a)); \
4645ffb0c9bSToomas Soome l; \
4655ffb0c9bSToomas Soome })
4664b22b933Srs
4674b22b933Srs # elif defined(__sparc) && defined(OPENSSL_SYS_ULTRASPARC)
4685ffb0c9bSToomas Soome # define LE_FETCH32(a) ({ register unsigned int l; \
4695ffb0c9bSToomas Soome asm ( \
4705ffb0c9bSToomas Soome "lda [%1]#ASI_PRIMARY_LITTLE,%0" \
4715ffb0c9bSToomas Soome : "=r" (l) \
4725ffb0c9bSToomas Soome : "r" (a)); \
4735ffb0c9bSToomas Soome l; \
4745ffb0c9bSToomas Soome })
4754b22b933Srs # endif
4764b22b933Srs # endif
4774b22b933Srs #endif /* PEDANTIC */
4784b22b933Srs
4795ffb0c9bSToomas Soome #if HASH_LONG_LOG2==2 /* Engage only if sizeof(HASH_LONG)== 4 */
4804b22b933Srs /* A nice byte order reversal from Wei Dai <weidai@eskimo.com> */
4814b22b933Srs #ifdef ROTATE
4824b22b933Srs /* 5 instructions with rotate instruction, else 9 */
4835ffb0c9bSToomas Soome #define REVERSE_FETCH32(a,l) ( \
4845ffb0c9bSToomas Soome l=*(const HASH_LONG *)(a), \
4855ffb0c9bSToomas Soome ((ROTATE(l,8)&0x00FF00FF)|(ROTATE((l&0x00FF00FF),24))) \
4865ffb0c9bSToomas Soome )
4874b22b933Srs #else
4884b22b933Srs /* 6 instructions with rotate instruction, else 8 */
4895ffb0c9bSToomas Soome #define REVERSE_FETCH32(a,l) ( \
4905ffb0c9bSToomas Soome l=*(const HASH_LONG *)(a), \
4915ffb0c9bSToomas Soome l=(((l>>8)&0x00FF00FF)|((l&0x00FF00FF)<<8)), \
4925ffb0c9bSToomas Soome ROTATE(l,16) \
4935ffb0c9bSToomas Soome )
4944b22b933Srs /*
4954b22b933Srs * Originally the middle line started with l=(((l&0xFF00FF00)>>8)|...
4964b22b933Srs * It's rewritten as above for two reasons:
4974b22b933Srs * - RISCs aren't good at long constants and have to explicitely
4984b22b933Srs * compose 'em with several (well, usually 2) instructions in a
4994b22b933Srs * register before performing the actual operation and (as you
5004b22b933Srs * already realized:-) having same constant should inspire the
5014b22b933Srs * compiler to permanently allocate the only register for it;
5024b22b933Srs * - most modern CPUs have two ALUs, but usually only one has
5034b22b933Srs * circuitry for shifts:-( this minor tweak inspires compiler
5044b22b933Srs * to schedule shift instructions in a better way...
5054b22b933Srs *
5064b22b933Srs * <appro@fy.chalmers.se>
5074b22b933Srs */
5084b22b933Srs #endif
5094b22b933Srs #endif
5104b22b933Srs
5114b22b933Srs #ifndef ROTATE
5124b22b933Srs #define ROTATE(a,n) (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
5134b22b933Srs #endif
5144b22b933Srs
5154b22b933Srs /*
5164b22b933Srs * Make some obvious choices. E.g., HASH_BLOCK_DATA_ORDER_ALIGNED
5174b22b933Srs * and HASH_BLOCK_HOST_ORDER ought to be the same if input data
5184b22b933Srs * and host are of the same "endianess". It's possible to mask
5194b22b933Srs * this with blank #define HASH_BLOCK_DATA_ORDER though...
5204b22b933Srs *
5214b22b933Srs * <appro@fy.chalmers.se>
5224b22b933Srs */
5234b22b933Srs #if defined(B_ENDIAN)
5244b22b933Srs # if defined(DATA_ORDER_IS_BIG_ENDIAN)
5254b22b933Srs # if !defined(HASH_BLOCK_DATA_ORDER_ALIGNED) && HASH_LONG_LOG2==2
5265ffb0c9bSToomas Soome # define HASH_BLOCK_DATA_ORDER_ALIGNED HASH_BLOCK_HOST_ORDER
5274b22b933Srs # endif
5284b22b933Srs # elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
5294b22b933Srs # ifndef HOST_FETCH32
5304b22b933Srs # ifdef LE_FETCH32
5315ffb0c9bSToomas Soome # define HOST_FETCH32(p,l) LE_FETCH32(p)
5324b22b933Srs # elif defined(REVERSE_FETCH32)
5335ffb0c9bSToomas Soome # define HOST_FETCH32(p,l) REVERSE_FETCH32(p,l)
5344b22b933Srs # endif
5354b22b933Srs # endif
5364b22b933Srs # endif
5374b22b933Srs #elif defined(L_ENDIAN)
5384b22b933Srs # if defined(DATA_ORDER_IS_LITTLE_ENDIAN)
5394b22b933Srs # if !defined(HASH_BLOCK_DATA_ORDER_ALIGNED) && HASH_LONG_LOG2==2
5405ffb0c9bSToomas Soome # define HASH_BLOCK_DATA_ORDER_ALIGNED HASH_BLOCK_HOST_ORDER
5414b22b933Srs # endif
5424b22b933Srs # elif defined(DATA_ORDER_IS_BIG_ENDIAN)
5434b22b933Srs # ifndef HOST_FETCH32
5444b22b933Srs # ifdef BE_FETCH32
5455ffb0c9bSToomas Soome # define HOST_FETCH32(p,l) BE_FETCH32(p)
5464b22b933Srs # elif defined(REVERSE_FETCH32)
5475ffb0c9bSToomas Soome # define HOST_FETCH32(p,l) REVERSE_FETCH32(p,l)
5484b22b933Srs # endif
5494b22b933Srs # endif
5504b22b933Srs # endif
5514b22b933Srs #endif
5524b22b933Srs
5534b22b933Srs #if !defined(HASH_BLOCK_DATA_ORDER_ALIGNED)
5544b22b933Srs #ifndef HASH_BLOCK_DATA_ORDER
5554b22b933Srs #error "HASH_BLOCK_DATA_ORDER must be defined!"
5564b22b933Srs #endif
5574b22b933Srs #endif
5584b22b933Srs
5595ffb0c9bSToomas Soome // None of the invocations of the following macros actually use the result,
5605ffb0c9bSToomas Soome // so cast them to void to avoid any compiler warnings/errors about not using
5615ffb0c9bSToomas Soome // the result (e.g. when using clang).
5625ffb0c9bSToomas Soome // If the resultant values need to be used at some point, these must be changed.
5635ffb0c9bSToomas Soome #define HOST_c2l(c,l) ((void)_HOST_c2l(c,l))
5645ffb0c9bSToomas Soome #define HOST_l2c(l,c) ((void)_HOST_l2c(l,c))
5655ffb0c9bSToomas Soome
5664b22b933Srs #if defined(DATA_ORDER_IS_BIG_ENDIAN)
5674b22b933Srs
5685ffb0c9bSToomas Soome #define _HOST_c2l(c,l) (l =(((unsigned long)(*((c)++)))<<24), \
5695ffb0c9bSToomas Soome l|=(((unsigned long)(*((c)++)))<<16), \
5705ffb0c9bSToomas Soome l|=(((unsigned long)(*((c)++)))<< 8), \
5715ffb0c9bSToomas Soome l|=(((unsigned long)(*((c)++))) ), \
5725ffb0c9bSToomas Soome l)
573*472cd20dSToomas Soome #define HOST_p_c2l(c,l,n) { \
574*472cd20dSToomas Soome switch (n) { \
5755ffb0c9bSToomas Soome case 0: l =((unsigned long)(*((c)++)))<<24; \
576*472cd20dSToomas Soome /* FALLTHROUGH */ \
5775ffb0c9bSToomas Soome case 1: l|=((unsigned long)(*((c)++)))<<16; \
578*472cd20dSToomas Soome /* FALLTHROUGH */ \
5795ffb0c9bSToomas Soome case 2: l|=((unsigned long)(*((c)++)))<< 8; \
580*472cd20dSToomas Soome /* FALLTHROUGH */ \
5815ffb0c9bSToomas Soome case 3: l|=((unsigned long)(*((c)++))); \
5825ffb0c9bSToomas Soome } }
5835ffb0c9bSToomas Soome #define HOST_p_c2l_p(c,l,sc,len) { \
584*472cd20dSToomas Soome switch (sc) { \
5855ffb0c9bSToomas Soome case 0: l =((unsigned long)(*((c)++)))<<24; \
586*472cd20dSToomas Soome if (--len == 0) break; \
587*472cd20dSToomas Soome /* FALLTHROUGH */ \
5885ffb0c9bSToomas Soome case 1: l|=((unsigned long)(*((c)++)))<<16; \
589*472cd20dSToomas Soome if (--len == 0) break; \
590*472cd20dSToomas Soome /* FALLTHROUGH */ \
5915ffb0c9bSToomas Soome case 2: l|=((unsigned long)(*((c)++)))<< 8; \
5925ffb0c9bSToomas Soome } }
5934b22b933Srs /* NOTE the pointer is not incremented at the end of this */
594*472cd20dSToomas Soome #define HOST_c2l_p(c,l,n) { \
595*472cd20dSToomas Soome l=0; (c)+=n; \
596*472cd20dSToomas Soome switch (n) { \
5975ffb0c9bSToomas Soome case 3: l =((unsigned long)(*(--(c))))<< 8; \
598*472cd20dSToomas Soome /* FALLTHROUGH */ \
5995ffb0c9bSToomas Soome case 2: l|=((unsigned long)(*(--(c))))<<16; \
600*472cd20dSToomas Soome /* FALLTHROUGH */ \
6015ffb0c9bSToomas Soome case 1: l|=((unsigned long)(*(--(c))))<<24; \
6025ffb0c9bSToomas Soome } }
6035ffb0c9bSToomas Soome #define _HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
6045ffb0c9bSToomas Soome *((c)++)=(unsigned char)(((l)>>16)&0xff), \
6055ffb0c9bSToomas Soome *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
6065ffb0c9bSToomas Soome *((c)++)=(unsigned char)(((l) )&0xff), \
6075ffb0c9bSToomas Soome l)
6084b22b933Srs
6094b22b933Srs #elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
6104b22b933Srs
6115ffb0c9bSToomas Soome #define _HOST_c2l(c,l) (l =(((unsigned long)(*((c)++))) ), \
6125ffb0c9bSToomas Soome l|=(((unsigned long)(*((c)++)))<< 8), \
6135ffb0c9bSToomas Soome l|=(((unsigned long)(*((c)++)))<<16), \
6145ffb0c9bSToomas Soome l|=(((unsigned long)(*((c)++)))<<24), \
6155ffb0c9bSToomas Soome l)
616*472cd20dSToomas Soome #define HOST_p_c2l(c,l,n) { \
617*472cd20dSToomas Soome switch (n) { \
6185ffb0c9bSToomas Soome case 0: l =((unsigned long)(*((c)++))); \
619*472cd20dSToomas Soome /* FALLTHROUGH */ \
6205ffb0c9bSToomas Soome case 1: l|=((unsigned long)(*((c)++)))<< 8; \
621*472cd20dSToomas Soome /* FALLTHROUGH */ \
6225ffb0c9bSToomas Soome case 2: l|=((unsigned long)(*((c)++)))<<16; \
623*472cd20dSToomas Soome /* FALLTHROUGH */ \
6245ffb0c9bSToomas Soome case 3: l|=((unsigned long)(*((c)++)))<<24; \
6255ffb0c9bSToomas Soome } }
6265ffb0c9bSToomas Soome #define HOST_p_c2l_p(c,l,sc,len) { \
627*472cd20dSToomas Soome switch (sc) { \
6285ffb0c9bSToomas Soome case 0: l =((unsigned long)(*((c)++))); \
629*472cd20dSToomas Soome if (--len == 0) break; \
630*472cd20dSToomas Soome /* FALLTHROUGH */ \
6315ffb0c9bSToomas Soome case 1: l|=((unsigned long)(*((c)++)))<< 8; \
632*472cd20dSToomas Soome if (--len == 0) break; \
633*472cd20dSToomas Soome /* FALLTHROUGH */ \
6345ffb0c9bSToomas Soome case 2: l|=((unsigned long)(*((c)++)))<<16; \
6355ffb0c9bSToomas Soome } }
6364b22b933Srs /* NOTE the pointer is not incremented at the end of this */
637*472cd20dSToomas Soome #define HOST_c2l_p(c,l,n) { \
638*472cd20dSToomas Soome l=0; (c)+=n; \
639*472cd20dSToomas Soome switch (n) { \
6405ffb0c9bSToomas Soome case 3: l =((unsigned long)(*(--(c))))<<16; \
641*472cd20dSToomas Soome /* FALLTHROUGH */ \
6425ffb0c9bSToomas Soome case 2: l|=((unsigned long)(*(--(c))))<< 8; \
643*472cd20dSToomas Soome /* FALLTHROUGH */ \
6445ffb0c9bSToomas Soome case 1: l|=((unsigned long)(*(--(c)))); \
6455ffb0c9bSToomas Soome } }
6465ffb0c9bSToomas Soome #define _HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
6475ffb0c9bSToomas Soome *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
6485ffb0c9bSToomas Soome *((c)++)=(unsigned char)(((l)>>16)&0xff), \
6495ffb0c9bSToomas Soome *((c)++)=(unsigned char)(((l)>>24)&0xff), \
6505ffb0c9bSToomas Soome l)
6514b22b933Srs
6524b22b933Srs #endif
6534b22b933Srs
6544b22b933Srs /*
6554b22b933Srs * Time for some action:-)
6564b22b933Srs */
6574b22b933Srs
HASH_UPDATE(HASH_CTX * c,const void * data_,unsigned long len)6584b22b933Srs int HASH_UPDATE (HASH_CTX *c, const void *data_, unsigned long len)
6595ffb0c9bSToomas Soome {
6605ffb0c9bSToomas Soome const unsigned char *data=(const unsigned char *)data_;
661*472cd20dSToomas Soome const unsigned char * const data_end=(const unsigned char *)data_;
6625ffb0c9bSToomas Soome register HASH_LONG * p;
6635ffb0c9bSToomas Soome register unsigned long l;
6645ffb0c9bSToomas Soome int sw,sc,ew,ec;
6655ffb0c9bSToomas Soome
6665ffb0c9bSToomas Soome if (len==0) return 1;
6675ffb0c9bSToomas Soome
6685ffb0c9bSToomas Soome l=(c->Nl+(len<<3))&0xffffffffL;
6695ffb0c9bSToomas Soome /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
6705ffb0c9bSToomas Soome * Wei Dai <weidai@eskimo.com> for pointing it out. */
6715ffb0c9bSToomas Soome if (l < c->Nl) /* overflow */
6725ffb0c9bSToomas Soome c->Nh++;
6735ffb0c9bSToomas Soome c->Nh+=(len>>29);
6745ffb0c9bSToomas Soome c->Nl=l;
6755ffb0c9bSToomas Soome
6765ffb0c9bSToomas Soome if (c->num != 0)
6775ffb0c9bSToomas Soome {
6785ffb0c9bSToomas Soome p=c->data;
6795ffb0c9bSToomas Soome sw=c->num>>2;
6805ffb0c9bSToomas Soome sc=c->num&0x03;
6815ffb0c9bSToomas Soome
6825ffb0c9bSToomas Soome if ((c->num+len) >= HASH_CBLOCK)
6835ffb0c9bSToomas Soome {
6845ffb0c9bSToomas Soome l=p[sw]; HOST_p_c2l(data,l,sc); p[sw++]=l;
685*472cd20dSToomas Soome for (; (sw < HASH_LBLOCK) && ((data_end - data) >= 4); sw++)
6865ffb0c9bSToomas Soome {
6875ffb0c9bSToomas Soome HOST_c2l(data,l); p[sw]=l;
6885ffb0c9bSToomas Soome }
6895ffb0c9bSToomas Soome HASH_BLOCK_HOST_ORDER (c,p,1);
6905ffb0c9bSToomas Soome len-=(HASH_CBLOCK-c->num);
6915ffb0c9bSToomas Soome c->num=0;
6925ffb0c9bSToomas Soome /* drop through and do the rest */
6935ffb0c9bSToomas Soome }
6945ffb0c9bSToomas Soome else
6955ffb0c9bSToomas Soome {
6965ffb0c9bSToomas Soome c->num+=len;
6975ffb0c9bSToomas Soome if ((sc+len) < 4) /* ugly, add char's to a word */
6985ffb0c9bSToomas Soome {
6995ffb0c9bSToomas Soome l=p[sw]; HOST_p_c2l_p(data,l,sc,len); p[sw]=l;
7005ffb0c9bSToomas Soome }
7015ffb0c9bSToomas Soome else
7025ffb0c9bSToomas Soome {
7035ffb0c9bSToomas Soome ew=(c->num>>2);
7045ffb0c9bSToomas Soome ec=(c->num&0x03);
7055ffb0c9bSToomas Soome if (sc)
7065ffb0c9bSToomas Soome l=p[sw];
7075ffb0c9bSToomas Soome HOST_p_c2l(data,l,sc);
7085ffb0c9bSToomas Soome p[sw++]=l;
709*472cd20dSToomas Soome for (; (sw < ew) && ((data_end - data) >= 4); sw++)
7105ffb0c9bSToomas Soome {
7115ffb0c9bSToomas Soome HOST_c2l(data,l); p[sw]=l;
7125ffb0c9bSToomas Soome }
7135ffb0c9bSToomas Soome if (ec)
7145ffb0c9bSToomas Soome {
7155ffb0c9bSToomas Soome HOST_c2l_p(data,l,ec); p[sw]=l;
7165ffb0c9bSToomas Soome }
7175ffb0c9bSToomas Soome }
7185ffb0c9bSToomas Soome return 1;
7195ffb0c9bSToomas Soome }
7205ffb0c9bSToomas Soome }
7215ffb0c9bSToomas Soome
7225ffb0c9bSToomas Soome sw=(int)(len/HASH_CBLOCK);
7235ffb0c9bSToomas Soome if (sw > 0)
7245ffb0c9bSToomas Soome {
7254b22b933Srs #if defined(HASH_BLOCK_DATA_ORDER_ALIGNED)
7265ffb0c9bSToomas Soome /*
7275ffb0c9bSToomas Soome * Note that HASH_BLOCK_DATA_ORDER_ALIGNED gets defined
7285ffb0c9bSToomas Soome * only if sizeof(HASH_LONG)==4.
7295ffb0c9bSToomas Soome */
7305ffb0c9bSToomas Soome if ((((unsigned long)data)%4) == 0)
7315ffb0c9bSToomas Soome {
7325ffb0c9bSToomas Soome /* data is properly aligned so that we can cast it: */
7335ffb0c9bSToomas Soome HASH_BLOCK_DATA_ORDER_ALIGNED (c,(HASH_LONG *)data,sw);
7345ffb0c9bSToomas Soome sw*=HASH_CBLOCK;
7355ffb0c9bSToomas Soome data+=sw;
7365ffb0c9bSToomas Soome len-=sw;
7375ffb0c9bSToomas Soome }
7385ffb0c9bSToomas Soome else
7394b22b933Srs #if !defined(HASH_BLOCK_DATA_ORDER)
7405ffb0c9bSToomas Soome while (sw--)
7415ffb0c9bSToomas Soome {
7425ffb0c9bSToomas Soome mDNSPlatformMemCopy(p=c->data,data,HASH_CBLOCK);
7435ffb0c9bSToomas Soome HASH_BLOCK_DATA_ORDER_ALIGNED(c,p,1);
7445ffb0c9bSToomas Soome data+=HASH_CBLOCK;
7455ffb0c9bSToomas Soome len-=HASH_CBLOCK;
7465ffb0c9bSToomas Soome }
7474b22b933Srs #endif
7484b22b933Srs #endif
7494b22b933Srs #if defined(HASH_BLOCK_DATA_ORDER)
7505ffb0c9bSToomas Soome {
7515ffb0c9bSToomas Soome HASH_BLOCK_DATA_ORDER(c,data,sw);
7525ffb0c9bSToomas Soome sw*=HASH_CBLOCK;
7535ffb0c9bSToomas Soome data+=sw;
7545ffb0c9bSToomas Soome len-=sw;
7555ffb0c9bSToomas Soome }
7564b22b933Srs #endif
7575ffb0c9bSToomas Soome }
7585ffb0c9bSToomas Soome
7595ffb0c9bSToomas Soome if (len!=0)
7605ffb0c9bSToomas Soome {
7615ffb0c9bSToomas Soome p = c->data;
7625ffb0c9bSToomas Soome c->num = (int)len;
7635ffb0c9bSToomas Soome ew=(int)(len>>2); /* words to copy */
7645ffb0c9bSToomas Soome ec=(int)(len&0x03);
765*472cd20dSToomas Soome for (; ew && ((data_end - data) >= 4); ew--,p++)
7665ffb0c9bSToomas Soome {
7675ffb0c9bSToomas Soome HOST_c2l(data,l); *p=l;
7685ffb0c9bSToomas Soome }
7695ffb0c9bSToomas Soome HOST_c2l_p(data,l,ec);
7705ffb0c9bSToomas Soome *p=l;
7715ffb0c9bSToomas Soome }
7725ffb0c9bSToomas Soome return 1;
7735ffb0c9bSToomas Soome }
7744b22b933Srs
7754b22b933Srs
HASH_TRANSFORM(HASH_CTX * c,const unsigned char * data)7764b22b933Srs void HASH_TRANSFORM (HASH_CTX *c, const unsigned char *data)
7775ffb0c9bSToomas Soome {
7784b22b933Srs #if defined(HASH_BLOCK_DATA_ORDER_ALIGNED)
7795ffb0c9bSToomas Soome if ((((unsigned long)data)%4) == 0)
7805ffb0c9bSToomas Soome /* data is properly aligned so that we can cast it: */
7815ffb0c9bSToomas Soome HASH_BLOCK_DATA_ORDER_ALIGNED (c,(HASH_LONG *)data,1);
7825ffb0c9bSToomas Soome else
7834b22b933Srs #if !defined(HASH_BLOCK_DATA_ORDER)
7845ffb0c9bSToomas Soome {
7855ffb0c9bSToomas Soome mDNSPlatformMemCopy(c->data,data,HASH_CBLOCK);
7865ffb0c9bSToomas Soome HASH_BLOCK_DATA_ORDER_ALIGNED (c,c->data,1);
7875ffb0c9bSToomas Soome }
7884b22b933Srs #endif
7894b22b933Srs #endif
7904b22b933Srs #if defined(HASH_BLOCK_DATA_ORDER)
7915ffb0c9bSToomas Soome HASH_BLOCK_DATA_ORDER (c,data,1);
7924b22b933Srs #endif
7935ffb0c9bSToomas Soome }
7944b22b933Srs
7954b22b933Srs
HASH_FINAL(unsigned char * md,HASH_CTX * c)7964b22b933Srs int HASH_FINAL (unsigned char *md, HASH_CTX *c)
7975ffb0c9bSToomas Soome {
7985ffb0c9bSToomas Soome register HASH_LONG *p;
7995ffb0c9bSToomas Soome register unsigned long l;
8005ffb0c9bSToomas Soome register int i,j;
8015ffb0c9bSToomas Soome static const unsigned char end[4]={0x80,0x00,0x00,0x00};
8025ffb0c9bSToomas Soome const unsigned char *cp=end;
8035ffb0c9bSToomas Soome
8045ffb0c9bSToomas Soome /* c->num should definitly have room for at least one more byte. */
8055ffb0c9bSToomas Soome p=c->data;
8065ffb0c9bSToomas Soome i=c->num>>2;
8075ffb0c9bSToomas Soome j=c->num&0x03;
8084b22b933Srs
8094b22b933Srs #if 0
8105ffb0c9bSToomas Soome /* purify often complains about the following line as an
8115ffb0c9bSToomas Soome * Uninitialized Memory Read. While this can be true, the
8125ffb0c9bSToomas Soome * following p_c2l macro will reset l when that case is true.
8135ffb0c9bSToomas Soome * This is because j&0x03 contains the number of 'valid' bytes
8145ffb0c9bSToomas Soome * already in p[i]. If and only if j&0x03 == 0, the UMR will
8155ffb0c9bSToomas Soome * occur but this is also the only time p_c2l will do
8165ffb0c9bSToomas Soome * l= *(cp++) instead of l|= *(cp++)
8175ffb0c9bSToomas Soome * Many thanks to Alex Tang <altitude@cic.net> for pickup this
8185ffb0c9bSToomas Soome * 'potential bug' */
8194b22b933Srs #ifdef PURIFY
8205ffb0c9bSToomas Soome if (j==0) p[i]=0; /* Yeah, but that's not the way to fix it:-) */
8214b22b933Srs #endif
8225ffb0c9bSToomas Soome l=p[i];
8234b22b933Srs #else
8245ffb0c9bSToomas Soome l = (j==0) ? 0 : p[i];
8254b22b933Srs #endif
8265ffb0c9bSToomas Soome HOST_p_c2l(cp,l,j); p[i++]=l; /* i is the next 'undefined word' */
8274b22b933Srs
8285ffb0c9bSToomas Soome if (i>(HASH_LBLOCK-2)) /* save room for Nl and Nh */
8295ffb0c9bSToomas Soome {
8305ffb0c9bSToomas Soome if (i<HASH_LBLOCK) p[i]=0;
8315ffb0c9bSToomas Soome HASH_BLOCK_HOST_ORDER (c,p,1);
8325ffb0c9bSToomas Soome i=0;
8335ffb0c9bSToomas Soome }
8345ffb0c9bSToomas Soome for (; i<(HASH_LBLOCK-2); i++)
8355ffb0c9bSToomas Soome p[i]=0;
8364b22b933Srs
8374b22b933Srs #if defined(DATA_ORDER_IS_BIG_ENDIAN)
8385ffb0c9bSToomas Soome p[HASH_LBLOCK-2]=c->Nh;
8395ffb0c9bSToomas Soome p[HASH_LBLOCK-1]=c->Nl;
8404b22b933Srs #elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
8415ffb0c9bSToomas Soome p[HASH_LBLOCK-2]=c->Nl;
8425ffb0c9bSToomas Soome p[HASH_LBLOCK-1]=c->Nh;
8434b22b933Srs #endif
8445ffb0c9bSToomas Soome HASH_BLOCK_HOST_ORDER (c,p,1);
8454b22b933Srs
8464b22b933Srs #ifndef HASH_MAKE_STRING
8474b22b933Srs #error "HASH_MAKE_STRING must be defined!"
8484b22b933Srs #else
8495ffb0c9bSToomas Soome HASH_MAKE_STRING(c,md);
8504b22b933Srs #endif
8514b22b933Srs
8525ffb0c9bSToomas Soome c->num=0;
8535ffb0c9bSToomas Soome /* clear stuff, HASH_BLOCK may be leaving some stuff on the stack
8545ffb0c9bSToomas Soome * but I'm not worried :-)
8555ffb0c9bSToomas Soome OPENSSL_cleanse((void *)c,sizeof(HASH_CTX));
8565ffb0c9bSToomas Soome */
8575ffb0c9bSToomas Soome return 1;
8585ffb0c9bSToomas Soome }
8594b22b933Srs
8604b22b933Srs #ifndef MD32_REG_T
8614b22b933Srs #define MD32_REG_T long
8624b22b933Srs /*
8634b22b933Srs * This comment was originaly written for MD5, which is why it
8644b22b933Srs * discusses A-D. But it basically applies to all 32-bit digests,
8654b22b933Srs * which is why it was moved to common header file.
8664b22b933Srs *
8674b22b933Srs * In case you wonder why A-D are declared as long and not
8684b22b933Srs * as mDNSu32. Doing so results in slight performance
8694b22b933Srs * boost on LP64 architectures. The catch is we don't
8704b22b933Srs * really care if 32 MSBs of a 64-bit register get polluted
8714b22b933Srs * with eventual overflows as we *save* only 32 LSBs in
8724b22b933Srs * *either* case. Now declaring 'em long excuses the compiler
8734b22b933Srs * from keeping 32 MSBs zeroed resulting in 13% performance
8744b22b933Srs * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
8755ffb0c9bSToomas Soome * Well, to be honest it should say that this *prevents*
8764b22b933Srs * performance degradation.
8774b22b933Srs * <appro@fy.chalmers.se>
8784b22b933Srs * Apparently there're LP64 compilers that generate better
8794b22b933Srs * code if A-D are declared int. Most notably GCC-x86_64
8804b22b933Srs * generates better code.
8814b22b933Srs * <appro@fy.chalmers.se>
8824b22b933Srs */
8834b22b933Srs #endif
8844b22b933Srs
8854b22b933Srs
8864b22b933Srs // from md5_locl.h (continued)
8874b22b933Srs
8884b22b933Srs /*
8895ffb0c9bSToomas Soome #define F(x,y,z) (((x) & (y)) | ((~(x)) & (z)))
8905ffb0c9bSToomas Soome #define G(x,y,z) (((x) & (z)) | ((y) & (~(z))))
8915ffb0c9bSToomas Soome */
8924b22b933Srs
8934b22b933Srs /* As pointed out by Wei Dai <weidai@eskimo.com>, the above can be
8944b22b933Srs * simplified to the code below. Wei attributes these optimizations
8954b22b933Srs * to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.
8964b22b933Srs */
8975ffb0c9bSToomas Soome #define F(b,c,d) ((((c) ^ (d)) & (b)) ^ (d))
8985ffb0c9bSToomas Soome #define G(b,c,d) ((((b) ^ (c)) & (d)) ^ (c))
8995ffb0c9bSToomas Soome #define H(b,c,d) ((b) ^ (c) ^ (d))
9005ffb0c9bSToomas Soome #define I(b,c,d) (((~(d)) | (b)) ^ (c))
9014b22b933Srs
9024b22b933Srs #define R0(a,b,c,d,k,s,t) { \
9035ffb0c9bSToomas Soome a+=((k)+(t)+F((b),(c),(d))); \
9045ffb0c9bSToomas Soome a=ROTATE(a,s); \
9055ffb0c9bSToomas Soome a+=b; }; \
9064b22b933Srs
9074b22b933Srs #define R1(a,b,c,d,k,s,t) { \
9085ffb0c9bSToomas Soome a+=((k)+(t)+G((b),(c),(d))); \
9095ffb0c9bSToomas Soome a=ROTATE(a,s); \
9105ffb0c9bSToomas Soome a+=b; };
9114b22b933Srs
9124b22b933Srs #define R2(a,b,c,d,k,s,t) { \
9135ffb0c9bSToomas Soome a+=((k)+(t)+H((b),(c),(d))); \
9145ffb0c9bSToomas Soome a=ROTATE(a,s); \
9155ffb0c9bSToomas Soome a+=b; };
9164b22b933Srs
9174b22b933Srs #define R3(a,b,c,d,k,s,t) { \
9185ffb0c9bSToomas Soome a+=((k)+(t)+I((b),(c),(d))); \
9195ffb0c9bSToomas Soome a=ROTATE(a,s); \
9205ffb0c9bSToomas Soome a+=b; };
9215ffb0c9bSToomas Soome
9224b22b933Srs // from md5_dgst.c
9234b22b933Srs
9244b22b933Srs
9254b22b933Srs /* Implemented from RFC1321 The MD5 Message-Digest Algorithm
9264b22b933Srs */
9274b22b933Srs
9284b22b933Srs #define INIT_DATA_A (unsigned long)0x67452301L
9294b22b933Srs #define INIT_DATA_B (unsigned long)0xefcdab89L
9304b22b933Srs #define INIT_DATA_C (unsigned long)0x98badcfeL
9314b22b933Srs #define INIT_DATA_D (unsigned long)0x10325476L
9324b22b933Srs
MD5_Init(MD5_CTX * c)9334b22b933Srs int MD5_Init(MD5_CTX *c)
9345ffb0c9bSToomas Soome {
9355ffb0c9bSToomas Soome c->A=INIT_DATA_A;
9365ffb0c9bSToomas Soome c->B=INIT_DATA_B;
9375ffb0c9bSToomas Soome c->C=INIT_DATA_C;
9385ffb0c9bSToomas Soome c->D=INIT_DATA_D;
9395ffb0c9bSToomas Soome c->Nl=0;
9405ffb0c9bSToomas Soome c->Nh=0;
9415ffb0c9bSToomas Soome c->num=0;
9425ffb0c9bSToomas Soome return 1;
9435ffb0c9bSToomas Soome }
9444b22b933Srs
9454b22b933Srs #ifndef md5_block_host_order
md5_block_host_order(MD5_CTX * c,const void * data,int num)9464b22b933Srs void md5_block_host_order (MD5_CTX *c, const void *data, int num)
9475ffb0c9bSToomas Soome {
9485ffb0c9bSToomas Soome const mDNSu32 *X=(const mDNSu32 *)data;
9495ffb0c9bSToomas Soome register unsigned MD32_REG_T A,B,C,D;
9505ffb0c9bSToomas Soome
9515ffb0c9bSToomas Soome A=c->A;
9525ffb0c9bSToomas Soome B=c->B;
9535ffb0c9bSToomas Soome C=c->C;
9545ffb0c9bSToomas Soome D=c->D;
9555ffb0c9bSToomas Soome
9565ffb0c9bSToomas Soome for (; num--; X+=HASH_LBLOCK)
9575ffb0c9bSToomas Soome {
9585ffb0c9bSToomas Soome /* Round 0 */
9595ffb0c9bSToomas Soome R0(A,B,C,D,X[ 0], 7,0xd76aa478L);
9605ffb0c9bSToomas Soome R0(D,A,B,C,X[ 1],12,0xe8c7b756L);
9615ffb0c9bSToomas Soome R0(C,D,A,B,X[ 2],17,0x242070dbL);
9625ffb0c9bSToomas Soome R0(B,C,D,A,X[ 3],22,0xc1bdceeeL);
9635ffb0c9bSToomas Soome R0(A,B,C,D,X[ 4], 7,0xf57c0fafL);
9645ffb0c9bSToomas Soome R0(D,A,B,C,X[ 5],12,0x4787c62aL);
9655ffb0c9bSToomas Soome R0(C,D,A,B,X[ 6],17,0xa8304613L);
9665ffb0c9bSToomas Soome R0(B,C,D,A,X[ 7],22,0xfd469501L);
9675ffb0c9bSToomas Soome R0(A,B,C,D,X[ 8], 7,0x698098d8L);
9685ffb0c9bSToomas Soome R0(D,A,B,C,X[ 9],12,0x8b44f7afL);
9695ffb0c9bSToomas Soome R0(C,D,A,B,X[10],17,0xffff5bb1L);
9705ffb0c9bSToomas Soome R0(B,C,D,A,X[11],22,0x895cd7beL);
9715ffb0c9bSToomas Soome R0(A,B,C,D,X[12], 7,0x6b901122L);
9725ffb0c9bSToomas Soome R0(D,A,B,C,X[13],12,0xfd987193L);
9735ffb0c9bSToomas Soome R0(C,D,A,B,X[14],17,0xa679438eL);
9745ffb0c9bSToomas Soome R0(B,C,D,A,X[15],22,0x49b40821L);
9755ffb0c9bSToomas Soome /* Round 1 */
9765ffb0c9bSToomas Soome R1(A,B,C,D,X[ 1], 5,0xf61e2562L);
9775ffb0c9bSToomas Soome R1(D,A,B,C,X[ 6], 9,0xc040b340L);
9785ffb0c9bSToomas Soome R1(C,D,A,B,X[11],14,0x265e5a51L);
9795ffb0c9bSToomas Soome R1(B,C,D,A,X[ 0],20,0xe9b6c7aaL);
9805ffb0c9bSToomas Soome R1(A,B,C,D,X[ 5], 5,0xd62f105dL);
9815ffb0c9bSToomas Soome R1(D,A,B,C,X[10], 9,0x02441453L);
9825ffb0c9bSToomas Soome R1(C,D,A,B,X[15],14,0xd8a1e681L);
9835ffb0c9bSToomas Soome R1(B,C,D,A,X[ 4],20,0xe7d3fbc8L);
9845ffb0c9bSToomas Soome R1(A,B,C,D,X[ 9], 5,0x21e1cde6L);
9855ffb0c9bSToomas Soome R1(D,A,B,C,X[14], 9,0xc33707d6L);
9865ffb0c9bSToomas Soome R1(C,D,A,B,X[ 3],14,0xf4d50d87L);
9875ffb0c9bSToomas Soome R1(B,C,D,A,X[ 8],20,0x455a14edL);
9885ffb0c9bSToomas Soome R1(A,B,C,D,X[13], 5,0xa9e3e905L);
9895ffb0c9bSToomas Soome R1(D,A,B,C,X[ 2], 9,0xfcefa3f8L);
9905ffb0c9bSToomas Soome R1(C,D,A,B,X[ 7],14,0x676f02d9L);
9915ffb0c9bSToomas Soome R1(B,C,D,A,X[12],20,0x8d2a4c8aL);
9925ffb0c9bSToomas Soome /* Round 2 */
9935ffb0c9bSToomas Soome R2(A,B,C,D,X[ 5], 4,0xfffa3942L);
9945ffb0c9bSToomas Soome R2(D,A,B,C,X[ 8],11,0x8771f681L);
9955ffb0c9bSToomas Soome R2(C,D,A,B,X[11],16,0x6d9d6122L);
9965ffb0c9bSToomas Soome R2(B,C,D,A,X[14],23,0xfde5380cL);
9975ffb0c9bSToomas Soome R2(A,B,C,D,X[ 1], 4,0xa4beea44L);
9985ffb0c9bSToomas Soome R2(D,A,B,C,X[ 4],11,0x4bdecfa9L);
9995ffb0c9bSToomas Soome R2(C,D,A,B,X[ 7],16,0xf6bb4b60L);
10005ffb0c9bSToomas Soome R2(B,C,D,A,X[10],23,0xbebfbc70L);
10015ffb0c9bSToomas Soome R2(A,B,C,D,X[13], 4,0x289b7ec6L);
10025ffb0c9bSToomas Soome R2(D,A,B,C,X[ 0],11,0xeaa127faL);
10035ffb0c9bSToomas Soome R2(C,D,A,B,X[ 3],16,0xd4ef3085L);
10045ffb0c9bSToomas Soome R2(B,C,D,A,X[ 6],23,0x04881d05L);
10055ffb0c9bSToomas Soome R2(A,B,C,D,X[ 9], 4,0xd9d4d039L);
10065ffb0c9bSToomas Soome R2(D,A,B,C,X[12],11,0xe6db99e5L);
10075ffb0c9bSToomas Soome R2(C,D,A,B,X[15],16,0x1fa27cf8L);
10085ffb0c9bSToomas Soome R2(B,C,D,A,X[ 2],23,0xc4ac5665L);
10095ffb0c9bSToomas Soome /* Round 3 */
10105ffb0c9bSToomas Soome R3(A,B,C,D,X[ 0], 6,0xf4292244L);
10115ffb0c9bSToomas Soome R3(D,A,B,C,X[ 7],10,0x432aff97L);
10125ffb0c9bSToomas Soome R3(C,D,A,B,X[14],15,0xab9423a7L);
10135ffb0c9bSToomas Soome R3(B,C,D,A,X[ 5],21,0xfc93a039L);
10145ffb0c9bSToomas Soome R3(A,B,C,D,X[12], 6,0x655b59c3L);
10155ffb0c9bSToomas Soome R3(D,A,B,C,X[ 3],10,0x8f0ccc92L);
10165ffb0c9bSToomas Soome R3(C,D,A,B,X[10],15,0xffeff47dL);
10175ffb0c9bSToomas Soome R3(B,C,D,A,X[ 1],21,0x85845dd1L);
10185ffb0c9bSToomas Soome R3(A,B,C,D,X[ 8], 6,0x6fa87e4fL);
10195ffb0c9bSToomas Soome R3(D,A,B,C,X[15],10,0xfe2ce6e0L);
10205ffb0c9bSToomas Soome R3(C,D,A,B,X[ 6],15,0xa3014314L);
10215ffb0c9bSToomas Soome R3(B,C,D,A,X[13],21,0x4e0811a1L);
10225ffb0c9bSToomas Soome R3(A,B,C,D,X[ 4], 6,0xf7537e82L);
10235ffb0c9bSToomas Soome R3(D,A,B,C,X[11],10,0xbd3af235L);
10245ffb0c9bSToomas Soome R3(C,D,A,B,X[ 2],15,0x2ad7d2bbL);
10255ffb0c9bSToomas Soome R3(B,C,D,A,X[ 9],21,0xeb86d391L);
10265ffb0c9bSToomas Soome
10275ffb0c9bSToomas Soome A = c->A += A;
10285ffb0c9bSToomas Soome B = c->B += B;
10295ffb0c9bSToomas Soome C = c->C += C;
10305ffb0c9bSToomas Soome D = c->D += D;
10315ffb0c9bSToomas Soome }
10325ffb0c9bSToomas Soome }
10334b22b933Srs #endif
10344b22b933Srs
10354b22b933Srs #ifndef md5_block_data_order
10364b22b933Srs #ifdef X
10374b22b933Srs #undef X
10384b22b933Srs #endif
md5_block_data_order(MD5_CTX * c,const void * data_,int num)10394b22b933Srs void md5_block_data_order (MD5_CTX *c, const void *data_, int num)
10405ffb0c9bSToomas Soome {
10415ffb0c9bSToomas Soome const unsigned char *data=data_;
10425ffb0c9bSToomas Soome register unsigned MD32_REG_T A,B,C,D,l;
10434b22b933Srs #ifndef MD32_XARRAY
10445ffb0c9bSToomas Soome /* See comment in crypto/sha/sha_locl.h for details. */
10455ffb0c9bSToomas Soome unsigned MD32_REG_T XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
10465ffb0c9bSToomas Soome XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
10475ffb0c9bSToomas Soome # define X(i) XX ## i
10484b22b933Srs #else
10495ffb0c9bSToomas Soome mDNSu32 XX[MD5_LBLOCK];
10505ffb0c9bSToomas Soome # define X(i) XX[i]
10514b22b933Srs #endif
10524b22b933Srs
10535ffb0c9bSToomas Soome A=c->A;
10545ffb0c9bSToomas Soome B=c->B;
10555ffb0c9bSToomas Soome C=c->C;
10565ffb0c9bSToomas Soome D=c->D;
10575ffb0c9bSToomas Soome
1058*472cd20dSToomas Soome #if defined(__clang_analyzer__)
1059*472cd20dSToomas Soome // Get rid of false positive analyzer warning.
1060*472cd20dSToomas Soome for (const unsigned char *_ptr = data; _ptr < &data[num * HASH_CBLOCK]; ++_ptr) {}
1061*472cd20dSToomas Soome #endif
10625ffb0c9bSToomas Soome for (; num--;)
10635ffb0c9bSToomas Soome {
10645ffb0c9bSToomas Soome HOST_c2l(data,l); X( 0)=l; HOST_c2l(data,l); X( 1)=l;
10655ffb0c9bSToomas Soome /* Round 0 */
10665ffb0c9bSToomas Soome R0(A,B,C,D,X( 0), 7,0xd76aa478L); HOST_c2l(data,l); X( 2)=l;
10675ffb0c9bSToomas Soome R0(D,A,B,C,X( 1),12,0xe8c7b756L); HOST_c2l(data,l); X( 3)=l;
10685ffb0c9bSToomas Soome R0(C,D,A,B,X( 2),17,0x242070dbL); HOST_c2l(data,l); X( 4)=l;
10695ffb0c9bSToomas Soome R0(B,C,D,A,X( 3),22,0xc1bdceeeL); HOST_c2l(data,l); X( 5)=l;
10705ffb0c9bSToomas Soome R0(A,B,C,D,X( 4), 7,0xf57c0fafL); HOST_c2l(data,l); X( 6)=l;
10715ffb0c9bSToomas Soome R0(D,A,B,C,X( 5),12,0x4787c62aL); HOST_c2l(data,l); X( 7)=l;
10725ffb0c9bSToomas Soome R0(C,D,A,B,X( 6),17,0xa8304613L); HOST_c2l(data,l); X( 8)=l;
10735ffb0c9bSToomas Soome R0(B,C,D,A,X( 7),22,0xfd469501L); HOST_c2l(data,l); X( 9)=l;
10745ffb0c9bSToomas Soome R0(A,B,C,D,X( 8), 7,0x698098d8L); HOST_c2l(data,l); X(10)=l;
10755ffb0c9bSToomas Soome R0(D,A,B,C,X( 9),12,0x8b44f7afL); HOST_c2l(data,l); X(11)=l;
10765ffb0c9bSToomas Soome R0(C,D,A,B,X(10),17,0xffff5bb1L); HOST_c2l(data,l); X(12)=l;
10775ffb0c9bSToomas Soome R0(B,C,D,A,X(11),22,0x895cd7beL); HOST_c2l(data,l); X(13)=l;
10785ffb0c9bSToomas Soome R0(A,B,C,D,X(12), 7,0x6b901122L); HOST_c2l(data,l); X(14)=l;
10795ffb0c9bSToomas Soome R0(D,A,B,C,X(13),12,0xfd987193L); HOST_c2l(data,l); X(15)=l;
10805ffb0c9bSToomas Soome R0(C,D,A,B,X(14),17,0xa679438eL);
10815ffb0c9bSToomas Soome R0(B,C,D,A,X(15),22,0x49b40821L);
10825ffb0c9bSToomas Soome /* Round 1 */
10835ffb0c9bSToomas Soome R1(A,B,C,D,X( 1), 5,0xf61e2562L);
10845ffb0c9bSToomas Soome R1(D,A,B,C,X( 6), 9,0xc040b340L);
10855ffb0c9bSToomas Soome R1(C,D,A,B,X(11),14,0x265e5a51L);
10865ffb0c9bSToomas Soome R1(B,C,D,A,X( 0),20,0xe9b6c7aaL);
10875ffb0c9bSToomas Soome R1(A,B,C,D,X( 5), 5,0xd62f105dL);
10885ffb0c9bSToomas Soome R1(D,A,B,C,X(10), 9,0x02441453L);
10895ffb0c9bSToomas Soome R1(C,D,A,B,X(15),14,0xd8a1e681L);
10905ffb0c9bSToomas Soome R1(B,C,D,A,X( 4),20,0xe7d3fbc8L);
10915ffb0c9bSToomas Soome R1(A,B,C,D,X( 9), 5,0x21e1cde6L);
10925ffb0c9bSToomas Soome R1(D,A,B,C,X(14), 9,0xc33707d6L);
10935ffb0c9bSToomas Soome R1(C,D,A,B,X( 3),14,0xf4d50d87L);
10945ffb0c9bSToomas Soome R1(B,C,D,A,X( 8),20,0x455a14edL);
10955ffb0c9bSToomas Soome R1(A,B,C,D,X(13), 5,0xa9e3e905L);
10965ffb0c9bSToomas Soome R1(D,A,B,C,X( 2), 9,0xfcefa3f8L);
10975ffb0c9bSToomas Soome R1(C,D,A,B,X( 7),14,0x676f02d9L);
10985ffb0c9bSToomas Soome R1(B,C,D,A,X(12),20,0x8d2a4c8aL);
10995ffb0c9bSToomas Soome /* Round 2 */
11005ffb0c9bSToomas Soome R2(A,B,C,D,X( 5), 4,0xfffa3942L);
11015ffb0c9bSToomas Soome R2(D,A,B,C,X( 8),11,0x8771f681L);
11025ffb0c9bSToomas Soome R2(C,D,A,B,X(11),16,0x6d9d6122L);
11035ffb0c9bSToomas Soome R2(B,C,D,A,X(14),23,0xfde5380cL);
11045ffb0c9bSToomas Soome R2(A,B,C,D,X( 1), 4,0xa4beea44L);
11055ffb0c9bSToomas Soome R2(D,A,B,C,X( 4),11,0x4bdecfa9L);
11065ffb0c9bSToomas Soome R2(C,D,A,B,X( 7),16,0xf6bb4b60L);
11075ffb0c9bSToomas Soome R2(B,C,D,A,X(10),23,0xbebfbc70L);
11085ffb0c9bSToomas Soome R2(A,B,C,D,X(13), 4,0x289b7ec6L);
11095ffb0c9bSToomas Soome R2(D,A,B,C,X( 0),11,0xeaa127faL);
11105ffb0c9bSToomas Soome R2(C,D,A,B,X( 3),16,0xd4ef3085L);
11115ffb0c9bSToomas Soome R2(B,C,D,A,X( 6),23,0x04881d05L);
11125ffb0c9bSToomas Soome R2(A,B,C,D,X( 9), 4,0xd9d4d039L);
11135ffb0c9bSToomas Soome R2(D,A,B,C,X(12),11,0xe6db99e5L);
11145ffb0c9bSToomas Soome R2(C,D,A,B,X(15),16,0x1fa27cf8L);
11155ffb0c9bSToomas Soome R2(B,C,D,A,X( 2),23,0xc4ac5665L);
11165ffb0c9bSToomas Soome /* Round 3 */
11175ffb0c9bSToomas Soome R3(A,B,C,D,X( 0), 6,0xf4292244L);
11185ffb0c9bSToomas Soome R3(D,A,B,C,X( 7),10,0x432aff97L);
11195ffb0c9bSToomas Soome R3(C,D,A,B,X(14),15,0xab9423a7L);
11205ffb0c9bSToomas Soome R3(B,C,D,A,X( 5),21,0xfc93a039L);
11215ffb0c9bSToomas Soome R3(A,B,C,D,X(12), 6,0x655b59c3L);
11225ffb0c9bSToomas Soome R3(D,A,B,C,X( 3),10,0x8f0ccc92L);
11235ffb0c9bSToomas Soome R3(C,D,A,B,X(10),15,0xffeff47dL);
11245ffb0c9bSToomas Soome R3(B,C,D,A,X( 1),21,0x85845dd1L);
11255ffb0c9bSToomas Soome R3(A,B,C,D,X( 8), 6,0x6fa87e4fL);
11265ffb0c9bSToomas Soome R3(D,A,B,C,X(15),10,0xfe2ce6e0L);
11275ffb0c9bSToomas Soome R3(C,D,A,B,X( 6),15,0xa3014314L);
11285ffb0c9bSToomas Soome R3(B,C,D,A,X(13),21,0x4e0811a1L);
11295ffb0c9bSToomas Soome R3(A,B,C,D,X( 4), 6,0xf7537e82L);
11305ffb0c9bSToomas Soome R3(D,A,B,C,X(11),10,0xbd3af235L);
11315ffb0c9bSToomas Soome R3(C,D,A,B,X( 2),15,0x2ad7d2bbL);
11325ffb0c9bSToomas Soome R3(B,C,D,A,X( 9),21,0xeb86d391L);
11335ffb0c9bSToomas Soome
11345ffb0c9bSToomas Soome A = c->A += A;
11355ffb0c9bSToomas Soome B = c->B += B;
11365ffb0c9bSToomas Soome C = c->C += C;
11375ffb0c9bSToomas Soome D = c->D += D;
11385ffb0c9bSToomas Soome }
11395ffb0c9bSToomas Soome }
11404b22b933Srs #endif
11414b22b933Srs
11424b22b933Srs
11435ffb0c9bSToomas Soome // ***************************************************************************
11444b22b933Srs #if COMPILER_LIKES_PRAGMA_MARK
11454b22b933Srs #pragma mark - base64 -> binary conversion
11464b22b933Srs #endif
11474b22b933Srs
11485ffb0c9bSToomas Soome static const char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
11494b22b933Srs static const char Pad64 = '=';
11504b22b933Srs
11514b22b933Srs
11524b22b933Srs #define mDNSisspace(x) (x == '\t' || x == '\n' || x == '\v' || x == '\f' || x == '\r' || x == ' ')
11534b22b933Srs
mDNSstrchr(const char * s,int c)11545ffb0c9bSToomas Soome mDNSlocal const char *mDNSstrchr(const char *s, int c)
11555ffb0c9bSToomas Soome {
11565ffb0c9bSToomas Soome while (1)
11575ffb0c9bSToomas Soome {
11585ffb0c9bSToomas Soome if (c == *s) return s;
11595ffb0c9bSToomas Soome if (!*s) return mDNSNULL;
11605ffb0c9bSToomas Soome s++;
11615ffb0c9bSToomas Soome }
11625ffb0c9bSToomas Soome }
11634b22b933Srs
11644b22b933Srs // skips all whitespace anywhere.
11654b22b933Srs // converts characters, four at a time, starting at (or after)
11664b22b933Srs // src from base - 64 numbers into three 8 bit bytes in the target area.
11674b22b933Srs // it returns the number of data bytes stored at the target, or -1 on error.
11684b22b933Srs // adapted from BIND sources
11694b22b933Srs
DNSDigest_Base64ToBin(const char * src,mDNSu8 * target,mDNSu32 targsize)11705ffb0c9bSToomas Soome mDNSlocal mDNSs32 DNSDigest_Base64ToBin(const char *src, mDNSu8 *target, mDNSu32 targsize)
11715ffb0c9bSToomas Soome {
11725ffb0c9bSToomas Soome int tarindex, state, ch;
11735ffb0c9bSToomas Soome const char *pos;
11745ffb0c9bSToomas Soome
11755ffb0c9bSToomas Soome state = 0;
11765ffb0c9bSToomas Soome tarindex = 0;
11775ffb0c9bSToomas Soome
11785ffb0c9bSToomas Soome while ((ch = *src++) != '\0') {
11795ffb0c9bSToomas Soome if (mDNSisspace(ch)) /* Skip whitespace anywhere. */
11805ffb0c9bSToomas Soome continue;
11815ffb0c9bSToomas Soome
11825ffb0c9bSToomas Soome if (ch == Pad64)
11835ffb0c9bSToomas Soome break;
11845ffb0c9bSToomas Soome
11855ffb0c9bSToomas Soome pos = mDNSstrchr(Base64, ch);
11865ffb0c9bSToomas Soome if (pos == 0) /* A non-base64 character. */
11875ffb0c9bSToomas Soome return (-1);
11885ffb0c9bSToomas Soome
11895ffb0c9bSToomas Soome switch (state) {
11905ffb0c9bSToomas Soome case 0:
11915ffb0c9bSToomas Soome if (target) {
11925ffb0c9bSToomas Soome if ((mDNSu32)tarindex >= targsize)
11935ffb0c9bSToomas Soome return (-1);
11945ffb0c9bSToomas Soome target[tarindex] = (mDNSu8)((pos - Base64) << 2);
11955ffb0c9bSToomas Soome }
11965ffb0c9bSToomas Soome state = 1;
11975ffb0c9bSToomas Soome break;
11985ffb0c9bSToomas Soome case 1:
11995ffb0c9bSToomas Soome if (target) {
12005ffb0c9bSToomas Soome if ((mDNSu32)tarindex + 1 >= targsize)
12015ffb0c9bSToomas Soome return (-1);
12025ffb0c9bSToomas Soome target[tarindex] |= (pos - Base64) >> 4;
12035ffb0c9bSToomas Soome target[tarindex+1] = (mDNSu8)(((pos - Base64) & 0x0f) << 4);
12045ffb0c9bSToomas Soome }
12055ffb0c9bSToomas Soome tarindex++;
12065ffb0c9bSToomas Soome state = 2;
12075ffb0c9bSToomas Soome break;
12085ffb0c9bSToomas Soome case 2:
12095ffb0c9bSToomas Soome if (target) {
12105ffb0c9bSToomas Soome if ((mDNSu32)tarindex + 1 >= targsize)
12115ffb0c9bSToomas Soome return (-1);
12125ffb0c9bSToomas Soome target[tarindex] |= (pos - Base64) >> 2;
12135ffb0c9bSToomas Soome target[tarindex+1] = (mDNSu8)(((pos - Base64) & 0x03) << 6);
12145ffb0c9bSToomas Soome }
12155ffb0c9bSToomas Soome tarindex++;
12165ffb0c9bSToomas Soome state = 3;
12175ffb0c9bSToomas Soome break;
12185ffb0c9bSToomas Soome case 3:
12195ffb0c9bSToomas Soome if (target) {
12205ffb0c9bSToomas Soome if ((mDNSu32)tarindex >= targsize)
12215ffb0c9bSToomas Soome return (-1);
12225ffb0c9bSToomas Soome target[tarindex] |= (pos - Base64);
12235ffb0c9bSToomas Soome }
12245ffb0c9bSToomas Soome tarindex++;
12255ffb0c9bSToomas Soome state = 0;
12265ffb0c9bSToomas Soome break;
12275ffb0c9bSToomas Soome default:
12285ffb0c9bSToomas Soome return -1;
12295ffb0c9bSToomas Soome }
12305ffb0c9bSToomas Soome }
12315ffb0c9bSToomas Soome
12325ffb0c9bSToomas Soome /*
12335ffb0c9bSToomas Soome * We are done decoding Base-64 chars. Let's see if we ended
12345ffb0c9bSToomas Soome * on a byte boundary, and/or with erroneous trailing characters.
12355ffb0c9bSToomas Soome */
12365ffb0c9bSToomas Soome
12375ffb0c9bSToomas Soome if (ch == Pad64) { /* We got a pad char. */
12385ffb0c9bSToomas Soome ch = *src++; /* Skip it, get next. */
12395ffb0c9bSToomas Soome switch (state) {
12405ffb0c9bSToomas Soome case 0: /* Invalid = in first position */
12415ffb0c9bSToomas Soome case 1: /* Invalid = in second position */
12425ffb0c9bSToomas Soome return (-1);
12435ffb0c9bSToomas Soome
12445ffb0c9bSToomas Soome case 2: /* Valid, means one byte of info */
12455ffb0c9bSToomas Soome /* Skip any number of spaces. */
12465ffb0c9bSToomas Soome for ((void)mDNSNULL; ch != '\0'; ch = *src++)
12475ffb0c9bSToomas Soome if (!mDNSisspace(ch))
12485ffb0c9bSToomas Soome break;
12495ffb0c9bSToomas Soome /* Make sure there is another trailing = sign. */
12505ffb0c9bSToomas Soome if (ch != Pad64)
12515ffb0c9bSToomas Soome return (-1);
12525ffb0c9bSToomas Soome ch = *src++; /* Skip the = */
12535ffb0c9bSToomas Soome /* Fall through to "single trailing =" case. */
12545ffb0c9bSToomas Soome /* FALLTHROUGH */
12555ffb0c9bSToomas Soome
12565ffb0c9bSToomas Soome case 3: /* Valid, means two bytes of info */
12575ffb0c9bSToomas Soome /*
12585ffb0c9bSToomas Soome * We know this char is an =. Is there anything but
12595ffb0c9bSToomas Soome * whitespace after it?
12605ffb0c9bSToomas Soome */
12615ffb0c9bSToomas Soome for ((void)mDNSNULL; ch != '\0'; ch = *src++)
12625ffb0c9bSToomas Soome if (!mDNSisspace(ch))
12635ffb0c9bSToomas Soome return (-1);
12645ffb0c9bSToomas Soome
12655ffb0c9bSToomas Soome /*
12665ffb0c9bSToomas Soome * Now make sure for cases 2 and 3 that the "extra"
12675ffb0c9bSToomas Soome * bits that slopped past the last full byte were
12685ffb0c9bSToomas Soome * zeros. If we don't check them, they become a
12695ffb0c9bSToomas Soome * subliminal channel.
12705ffb0c9bSToomas Soome */
12715ffb0c9bSToomas Soome if (target && target[tarindex] != 0)
12725ffb0c9bSToomas Soome return (-1);
12735ffb0c9bSToomas Soome }
12745ffb0c9bSToomas Soome } else {
12755ffb0c9bSToomas Soome /*
12765ffb0c9bSToomas Soome * We ended by seeing the end of the string. Make sure we
12775ffb0c9bSToomas Soome * have no partial bytes lying around.
12785ffb0c9bSToomas Soome */
12795ffb0c9bSToomas Soome if (state != 0)
12805ffb0c9bSToomas Soome return (-1);
12815ffb0c9bSToomas Soome }
12825ffb0c9bSToomas Soome
12835ffb0c9bSToomas Soome return (tarindex);
12845ffb0c9bSToomas Soome }
12855ffb0c9bSToomas Soome
12865ffb0c9bSToomas Soome
12875ffb0c9bSToomas Soome // ***************************************************************************
12884b22b933Srs #if COMPILER_LIKES_PRAGMA_MARK
12894b22b933Srs #pragma mark - API exported to mDNS Core
12904b22b933Srs #endif
12914b22b933Srs
12924b22b933Srs // Constants
12934b22b933Srs #define HMAC_IPAD 0x36
12944b22b933Srs #define HMAC_OPAD 0x5c
12954b22b933Srs #define MD5_LEN 16
12964b22b933Srs
1297*472cd20dSToomas Soome #define HMAC_MD5_AlgName "\010" "hmac-md5" "\007" "sig-alg" "\003" "reg" "\003" "int"
12984b22b933Srs
12994b22b933Srs // Adapted from Appendix, RFC 2104
DNSDigest_ConstructHMACKey(DomainAuthInfo * info,const mDNSu8 * key,mDNSu32 len)13005ffb0c9bSToomas Soome mDNSlocal void DNSDigest_ConstructHMACKey(DomainAuthInfo *info, const mDNSu8 *key, mDNSu32 len)
13015ffb0c9bSToomas Soome {
13025ffb0c9bSToomas Soome MD5_CTX k;
13035ffb0c9bSToomas Soome mDNSu8 buf[MD5_LEN];
13045ffb0c9bSToomas Soome int i;
13055ffb0c9bSToomas Soome
13065ffb0c9bSToomas Soome // If key is longer than HMAC_LEN reset it to MD5(key)
13075ffb0c9bSToomas Soome if (len > HMAC_LEN)
13085ffb0c9bSToomas Soome {
13095ffb0c9bSToomas Soome MD5_Init(&k);
13105ffb0c9bSToomas Soome MD5_Update(&k, key, len);
13115ffb0c9bSToomas Soome MD5_Final(buf, &k);
13125ffb0c9bSToomas Soome key = buf;
13135ffb0c9bSToomas Soome len = MD5_LEN;
13145ffb0c9bSToomas Soome }
13155ffb0c9bSToomas Soome
13165ffb0c9bSToomas Soome // store key in pads
13175ffb0c9bSToomas Soome mDNSPlatformMemZero(info->keydata_ipad, HMAC_LEN);
13185ffb0c9bSToomas Soome mDNSPlatformMemZero(info->keydata_opad, HMAC_LEN);
13195ffb0c9bSToomas Soome mDNSPlatformMemCopy(info->keydata_ipad, key, len);
13205ffb0c9bSToomas Soome mDNSPlatformMemCopy(info->keydata_opad, key, len);
13215ffb0c9bSToomas Soome
13225ffb0c9bSToomas Soome // XOR key with ipad and opad values
13235ffb0c9bSToomas Soome for (i = 0; i < HMAC_LEN; i++)
13245ffb0c9bSToomas Soome {
13255ffb0c9bSToomas Soome info->keydata_ipad[i] ^= HMAC_IPAD;
13265ffb0c9bSToomas Soome info->keydata_opad[i] ^= HMAC_OPAD;
13275ffb0c9bSToomas Soome }
13285ffb0c9bSToomas Soome
13295ffb0c9bSToomas Soome }
13305ffb0c9bSToomas Soome
DNSDigest_ConstructHMACKeyfromBase64(DomainAuthInfo * info,const char * b64key)13315ffb0c9bSToomas Soome mDNSexport mDNSs32 DNSDigest_ConstructHMACKeyfromBase64(DomainAuthInfo *info, const char *b64key)
13325ffb0c9bSToomas Soome {
13335ffb0c9bSToomas Soome mDNSu8 keybuf[1024];
13345ffb0c9bSToomas Soome mDNSs32 keylen = DNSDigest_Base64ToBin(b64key, keybuf, sizeof(keybuf));
13355ffb0c9bSToomas Soome if (keylen < 0) return(keylen);
13365ffb0c9bSToomas Soome DNSDigest_ConstructHMACKey(info, keybuf, (mDNSu32)keylen);
13375ffb0c9bSToomas Soome return(keylen);
13385ffb0c9bSToomas Soome }
13395ffb0c9bSToomas Soome
DNSDigest_SignMessage(DNSMessage * msg,mDNSu8 ** end,DomainAuthInfo * info,mDNSu16 tcode)13405ffb0c9bSToomas Soome mDNSexport void DNSDigest_SignMessage(DNSMessage *msg, mDNSu8 **end, DomainAuthInfo *info, mDNSu16 tcode)
13415ffb0c9bSToomas Soome {
13425ffb0c9bSToomas Soome AuthRecord tsig;
13435ffb0c9bSToomas Soome mDNSu8 *rdata, *const countPtr = (mDNSu8 *)&msg->h.numAdditionals; // Get existing numAdditionals value
13445ffb0c9bSToomas Soome mDNSu32 utc32;
13455ffb0c9bSToomas Soome mDNSu8 utc48[6];
13465ffb0c9bSToomas Soome mDNSu8 digest[MD5_LEN];
13475ffb0c9bSToomas Soome mDNSu8 *ptr = *end;
13485ffb0c9bSToomas Soome mDNSu32 len;
13495ffb0c9bSToomas Soome mDNSOpaque16 buf;
13505ffb0c9bSToomas Soome MD5_CTX c;
13515ffb0c9bSToomas Soome mDNSu16 numAdditionals = (mDNSu16)((mDNSu16)countPtr[0] << 8 | countPtr[1]);
13525ffb0c9bSToomas Soome
13535ffb0c9bSToomas Soome // Init MD5 context, digest inner key pad and message
13544b22b933Srs MD5_Init(&c);
13555ffb0c9bSToomas Soome MD5_Update(&c, info->keydata_ipad, HMAC_LEN);
13565ffb0c9bSToomas Soome MD5_Update(&c, (mDNSu8 *)msg, (unsigned long)(*end - (mDNSu8 *)msg));
13575ffb0c9bSToomas Soome
13585ffb0c9bSToomas Soome // Construct TSIG RR, digesting variables as apporpriate
13595ffb0c9bSToomas Soome mDNS_SetupResourceRecord(&tsig, mDNSNULL, 0, kDNSType_TSIG, 0, kDNSRecordTypeKnownUnique, AuthRecordAny, mDNSNULL, mDNSNULL);
13605ffb0c9bSToomas Soome
13615ffb0c9bSToomas Soome // key name
13625ffb0c9bSToomas Soome AssignDomainName(&tsig.namestorage, &info->keyname);
13635ffb0c9bSToomas Soome MD5_Update(&c, info->keyname.c, DomainNameLength(&info->keyname));
13645ffb0c9bSToomas Soome
13655ffb0c9bSToomas Soome // class
13665ffb0c9bSToomas Soome tsig.resrec.rrclass = kDNSQClass_ANY;
13675ffb0c9bSToomas Soome buf = mDNSOpaque16fromIntVal(kDNSQClass_ANY);
13685ffb0c9bSToomas Soome MD5_Update(&c, buf.b, sizeof(mDNSOpaque16));
13695ffb0c9bSToomas Soome
13705ffb0c9bSToomas Soome // ttl
13715ffb0c9bSToomas Soome tsig.resrec.rroriginalttl = 0;
13725ffb0c9bSToomas Soome MD5_Update(&c, (mDNSu8 *)&tsig.resrec.rroriginalttl, sizeof(tsig.resrec.rroriginalttl));
13735ffb0c9bSToomas Soome
13745ffb0c9bSToomas Soome // alg name
1375*472cd20dSToomas Soome AssignConstStringDomainName(&tsig.resrec.rdata->u.name, HMAC_MD5_AlgName);
1376*472cd20dSToomas Soome len = DomainNameLengthLimit((domainname *)HMAC_MD5_AlgName, (mDNSu8 *)HMAC_MD5_AlgName + sizeof HMAC_MD5_AlgName);
13775ffb0c9bSToomas Soome rdata = tsig.resrec.rdata->u.data + len;
1378*472cd20dSToomas Soome MD5_Update(&c, (mDNSu8 *)HMAC_MD5_AlgName, len);
13795ffb0c9bSToomas Soome
13805ffb0c9bSToomas Soome // time
13815ffb0c9bSToomas Soome // get UTC (universal time), convert to 48-bit unsigned in network byte order
13825ffb0c9bSToomas Soome utc32 = (mDNSu32)mDNSPlatformUTC();
13835ffb0c9bSToomas Soome if (utc32 == (unsigned)-1) { LogMsg("ERROR: DNSDigest_SignMessage - mDNSPlatformUTC returned bad time -1"); *end = mDNSNULL; }
13845ffb0c9bSToomas Soome utc48[0] = 0;
13855ffb0c9bSToomas Soome utc48[1] = 0;
13865ffb0c9bSToomas Soome utc48[2] = (mDNSu8)((utc32 >> 24) & 0xff);
13875ffb0c9bSToomas Soome utc48[3] = (mDNSu8)((utc32 >> 16) & 0xff);
13885ffb0c9bSToomas Soome utc48[4] = (mDNSu8)((utc32 >> 8) & 0xff);
13895ffb0c9bSToomas Soome utc48[5] = (mDNSu8)( utc32 & 0xff);
13905ffb0c9bSToomas Soome
13915ffb0c9bSToomas Soome mDNSPlatformMemCopy(rdata, utc48, 6);
13925ffb0c9bSToomas Soome rdata += 6;
13935ffb0c9bSToomas Soome MD5_Update(&c, utc48, 6);
13945ffb0c9bSToomas Soome
13955ffb0c9bSToomas Soome // 300 sec is fudge recommended in RFC 2485
13965ffb0c9bSToomas Soome rdata[0] = (mDNSu8)((300 >> 8) & 0xff);
13975ffb0c9bSToomas Soome rdata[1] = (mDNSu8)( 300 & 0xff);
13985ffb0c9bSToomas Soome MD5_Update(&c, rdata, sizeof(mDNSOpaque16));
13995ffb0c9bSToomas Soome rdata += sizeof(mDNSOpaque16);
14005ffb0c9bSToomas Soome
14015ffb0c9bSToomas Soome // digest error (tcode) and other data len (zero) - we'll add them to the rdata later
14025ffb0c9bSToomas Soome buf.b[0] = (mDNSu8)((tcode >> 8) & 0xff);
14035ffb0c9bSToomas Soome buf.b[1] = (mDNSu8)( tcode & 0xff);
14045ffb0c9bSToomas Soome MD5_Update(&c, buf.b, sizeof(mDNSOpaque16)); // error
14055ffb0c9bSToomas Soome buf.NotAnInteger = 0;
14065ffb0c9bSToomas Soome MD5_Update(&c, buf.b, sizeof(mDNSOpaque16)); // other data len
14075ffb0c9bSToomas Soome
14085ffb0c9bSToomas Soome // finish the message & tsig var hash
14094b22b933Srs MD5_Final(digest, &c);
14105ffb0c9bSToomas Soome
14115ffb0c9bSToomas Soome // perform outer MD5 (outer key pad, inner digest)
14125ffb0c9bSToomas Soome MD5_Init(&c);
14135ffb0c9bSToomas Soome MD5_Update(&c, info->keydata_opad, HMAC_LEN);
14145ffb0c9bSToomas Soome MD5_Update(&c, digest, MD5_LEN);
14155ffb0c9bSToomas Soome MD5_Final(digest, &c);
14165ffb0c9bSToomas Soome
14175ffb0c9bSToomas Soome // set remaining rdata fields
14185ffb0c9bSToomas Soome rdata[0] = (mDNSu8)((MD5_LEN >> 8) & 0xff);
14195ffb0c9bSToomas Soome rdata[1] = (mDNSu8)( MD5_LEN & 0xff);
14205ffb0c9bSToomas Soome rdata += sizeof(mDNSOpaque16);
14215ffb0c9bSToomas Soome mDNSPlatformMemCopy(rdata, digest, MD5_LEN); // MAC
14225ffb0c9bSToomas Soome rdata += MD5_LEN;
14235ffb0c9bSToomas Soome rdata[0] = msg->h.id.b[0]; // original ID
14245ffb0c9bSToomas Soome rdata[1] = msg->h.id.b[1];
14255ffb0c9bSToomas Soome rdata[2] = (mDNSu8)((tcode >> 8) & 0xff);
14265ffb0c9bSToomas Soome rdata[3] = (mDNSu8)( tcode & 0xff);
14275ffb0c9bSToomas Soome rdata[4] = 0; // other data len
14285ffb0c9bSToomas Soome rdata[5] = 0;
14295ffb0c9bSToomas Soome rdata += 6;
14305ffb0c9bSToomas Soome
14315ffb0c9bSToomas Soome tsig.resrec.rdlength = (mDNSu16)(rdata - tsig.resrec.rdata->u.data);
14325ffb0c9bSToomas Soome *end = PutResourceRecordTTLJumbo(msg, ptr, &numAdditionals, &tsig.resrec, 0);
14335ffb0c9bSToomas Soome if (!*end) { LogMsg("ERROR: DNSDigest_SignMessage - could not put TSIG"); *end = mDNSNULL; return; }
14345ffb0c9bSToomas Soome
14355ffb0c9bSToomas Soome // Write back updated numAdditionals value
14365ffb0c9bSToomas Soome countPtr[0] = (mDNSu8)(numAdditionals >> 8);
14375ffb0c9bSToomas Soome countPtr[1] = (mDNSu8)(numAdditionals & 0xFF);
14385ffb0c9bSToomas Soome }
14395ffb0c9bSToomas Soome
DNSDigest_VerifyMessage(DNSMessage * msg,mDNSu8 * end,LargeCacheRecord * lcr,DomainAuthInfo * info,mDNSu16 * rcode,mDNSu16 * tcode)14405ffb0c9bSToomas Soome mDNSexport mDNSBool DNSDigest_VerifyMessage(DNSMessage *msg, mDNSu8 *end, LargeCacheRecord * lcr, DomainAuthInfo *info, mDNSu16 * rcode, mDNSu16 * tcode)
14415ffb0c9bSToomas Soome {
14425ffb0c9bSToomas Soome mDNSu8 * ptr = (mDNSu8*) &lcr->r.resrec.rdata->u.data;
14435ffb0c9bSToomas Soome mDNSs32 now;
14445ffb0c9bSToomas Soome mDNSs32 then;
14455ffb0c9bSToomas Soome mDNSu8 thisDigest[MD5_LEN];
14465ffb0c9bSToomas Soome mDNSu8 thatDigest[MD5_LEN];
14475ffb0c9bSToomas Soome mDNSOpaque16 buf;
14485ffb0c9bSToomas Soome mDNSu8 utc48[6];
14495ffb0c9bSToomas Soome mDNSs32 delta;
14505ffb0c9bSToomas Soome mDNSu16 fudge;
14515ffb0c9bSToomas Soome domainname * algo;
14525ffb0c9bSToomas Soome MD5_CTX c;
14535ffb0c9bSToomas Soome mDNSBool ok = mDNSfalse;
14545ffb0c9bSToomas Soome
14555ffb0c9bSToomas Soome // We only support HMAC-MD5 for now
14565ffb0c9bSToomas Soome
14575ffb0c9bSToomas Soome algo = (domainname*) ptr;
14585ffb0c9bSToomas Soome
1459*472cd20dSToomas Soome if (!SameDomainName(algo, (domainname *)HMAC_MD5_AlgName))
14605ffb0c9bSToomas Soome {
14615ffb0c9bSToomas Soome LogMsg("ERROR: DNSDigest_VerifyMessage - TSIG algorithm not supported: %##s", algo->c);
14625ffb0c9bSToomas Soome *rcode = kDNSFlag1_RC_NotAuth;
14635ffb0c9bSToomas Soome *tcode = TSIG_ErrBadKey;
14645ffb0c9bSToomas Soome ok = mDNSfalse;
14655ffb0c9bSToomas Soome goto exit;
14665ffb0c9bSToomas Soome }
14675ffb0c9bSToomas Soome
14685ffb0c9bSToomas Soome ptr += DomainNameLength(algo);
14695ffb0c9bSToomas Soome
14705ffb0c9bSToomas Soome // Check the times
14715ffb0c9bSToomas Soome
14725ffb0c9bSToomas Soome now = mDNSPlatformUTC();
14735ffb0c9bSToomas Soome if (now == -1)
14745ffb0c9bSToomas Soome {
14755ffb0c9bSToomas Soome LogMsg("ERROR: DNSDigest_VerifyMessage - mDNSPlatformUTC returned bad time -1");
14765ffb0c9bSToomas Soome *rcode = kDNSFlag1_RC_NotAuth;
14775ffb0c9bSToomas Soome *tcode = TSIG_ErrBadTime;
14785ffb0c9bSToomas Soome ok = mDNSfalse;
14795ffb0c9bSToomas Soome goto exit;
14805ffb0c9bSToomas Soome }
14815ffb0c9bSToomas Soome
14825ffb0c9bSToomas Soome // Get the 48 bit time field, skipping over the first word
14835ffb0c9bSToomas Soome
14845ffb0c9bSToomas Soome utc48[0] = *ptr++;
14855ffb0c9bSToomas Soome utc48[1] = *ptr++;
14865ffb0c9bSToomas Soome utc48[2] = *ptr++;
14875ffb0c9bSToomas Soome utc48[3] = *ptr++;
14885ffb0c9bSToomas Soome utc48[4] = *ptr++;
14895ffb0c9bSToomas Soome utc48[5] = *ptr++;
14905ffb0c9bSToomas Soome
14915ffb0c9bSToomas Soome then = (mDNSs32)NToH32(utc48 + sizeof(mDNSu16));
14925ffb0c9bSToomas Soome
14935ffb0c9bSToomas Soome fudge = NToH16(ptr);
14945ffb0c9bSToomas Soome
14955ffb0c9bSToomas Soome ptr += sizeof(mDNSu16);
14965ffb0c9bSToomas Soome
14975ffb0c9bSToomas Soome delta = (now > then) ? now - then : then - now;
14985ffb0c9bSToomas Soome
14995ffb0c9bSToomas Soome if (delta > fudge)
15005ffb0c9bSToomas Soome {
15015ffb0c9bSToomas Soome LogMsg("ERROR: DNSDigest_VerifyMessage - time skew > %d", fudge);
15025ffb0c9bSToomas Soome *rcode = kDNSFlag1_RC_NotAuth;
15035ffb0c9bSToomas Soome *tcode = TSIG_ErrBadTime;
15045ffb0c9bSToomas Soome ok = mDNSfalse;
15055ffb0c9bSToomas Soome goto exit;
15065ffb0c9bSToomas Soome }
15075ffb0c9bSToomas Soome
15085ffb0c9bSToomas Soome // MAC size
15095ffb0c9bSToomas Soome
15105ffb0c9bSToomas Soome ptr += sizeof(mDNSu16);
15115ffb0c9bSToomas Soome
15125ffb0c9bSToomas Soome // MAC
15135ffb0c9bSToomas Soome
15145ffb0c9bSToomas Soome mDNSPlatformMemCopy(thatDigest, ptr, MD5_LEN);
15155ffb0c9bSToomas Soome
15165ffb0c9bSToomas Soome // Init MD5 context, digest inner key pad and message
15175ffb0c9bSToomas Soome
15185ffb0c9bSToomas Soome MD5_Init(&c);
15195ffb0c9bSToomas Soome MD5_Update(&c, info->keydata_ipad, HMAC_LEN);
15205ffb0c9bSToomas Soome MD5_Update(&c, (mDNSu8*) msg, (unsigned long)(end - (mDNSu8*) msg));
15215ffb0c9bSToomas Soome
15225ffb0c9bSToomas Soome // Key name
15235ffb0c9bSToomas Soome
15245ffb0c9bSToomas Soome MD5_Update(&c, lcr->r.resrec.name->c, DomainNameLength(lcr->r.resrec.name));
15255ffb0c9bSToomas Soome
15265ffb0c9bSToomas Soome // Class name
15275ffb0c9bSToomas Soome
15285ffb0c9bSToomas Soome buf = mDNSOpaque16fromIntVal(lcr->r.resrec.rrclass);
15295ffb0c9bSToomas Soome MD5_Update(&c, buf.b, sizeof(mDNSOpaque16));
15305ffb0c9bSToomas Soome
15315ffb0c9bSToomas Soome // TTL
15325ffb0c9bSToomas Soome
15335ffb0c9bSToomas Soome MD5_Update(&c, (mDNSu8*) &lcr->r.resrec.rroriginalttl, sizeof(lcr->r.resrec.rroriginalttl));
15345ffb0c9bSToomas Soome
15355ffb0c9bSToomas Soome // Algorithm
15365ffb0c9bSToomas Soome
15375ffb0c9bSToomas Soome MD5_Update(&c, algo->c, DomainNameLength(algo));
15385ffb0c9bSToomas Soome
15395ffb0c9bSToomas Soome // Time
15405ffb0c9bSToomas Soome
15415ffb0c9bSToomas Soome MD5_Update(&c, utc48, 6);
15425ffb0c9bSToomas Soome
15435ffb0c9bSToomas Soome // Fudge
15445ffb0c9bSToomas Soome
15455ffb0c9bSToomas Soome buf = mDNSOpaque16fromIntVal(fudge);
15465ffb0c9bSToomas Soome MD5_Update(&c, buf.b, sizeof(mDNSOpaque16));
15475ffb0c9bSToomas Soome
15485ffb0c9bSToomas Soome // Digest error and other data len (both zero) - we'll add them to the rdata later
15495ffb0c9bSToomas Soome
15505ffb0c9bSToomas Soome buf.NotAnInteger = 0;
15515ffb0c9bSToomas Soome MD5_Update(&c, buf.b, sizeof(mDNSOpaque16)); // error
15525ffb0c9bSToomas Soome MD5_Update(&c, buf.b, sizeof(mDNSOpaque16)); // other data len
15535ffb0c9bSToomas Soome
15545ffb0c9bSToomas Soome // Finish the message & tsig var hash
15555ffb0c9bSToomas Soome
15565ffb0c9bSToomas Soome MD5_Final(thisDigest, &c);
15575ffb0c9bSToomas Soome
15585ffb0c9bSToomas Soome // perform outer MD5 (outer key pad, inner digest)
15595ffb0c9bSToomas Soome
15605ffb0c9bSToomas Soome MD5_Init(&c);
15615ffb0c9bSToomas Soome MD5_Update(&c, info->keydata_opad, HMAC_LEN);
15625ffb0c9bSToomas Soome MD5_Update(&c, thisDigest, MD5_LEN);
15635ffb0c9bSToomas Soome MD5_Final(thisDigest, &c);
15645ffb0c9bSToomas Soome
15655ffb0c9bSToomas Soome if (!mDNSPlatformMemSame(thisDigest, thatDigest, MD5_LEN))
15665ffb0c9bSToomas Soome {
15675ffb0c9bSToomas Soome LogMsg("ERROR: DNSDigest_VerifyMessage - bad signature");
15685ffb0c9bSToomas Soome *rcode = kDNSFlag1_RC_NotAuth;
15695ffb0c9bSToomas Soome *tcode = TSIG_ErrBadSig;
15705ffb0c9bSToomas Soome ok = mDNSfalse;
15715ffb0c9bSToomas Soome goto exit;
15725ffb0c9bSToomas Soome }
15735ffb0c9bSToomas Soome
15745ffb0c9bSToomas Soome // set remaining rdata fields
15755ffb0c9bSToomas Soome ok = mDNStrue;
15765ffb0c9bSToomas Soome
15775ffb0c9bSToomas Soome exit:
15785ffb0c9bSToomas Soome
15795ffb0c9bSToomas Soome return ok;
15805ffb0c9bSToomas Soome }
15815ffb0c9bSToomas Soome
15824b22b933Srs
15834b22b933Srs #ifdef __cplusplus
15844b22b933Srs }
15854b22b933Srs #endif
1586