144290Swollman/* crypto/sha/sha1dgst.c */ 244290Swollman/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 344290Swollman * All rights reserved. 444290Swollman * 544290Swollman * This package is an SSL implementation written 644290Swollman * by Eric Young (eay@cryptsoft.com). 744290Swollman * The implementation was written so as to conform with Netscapes SSL. 844290Swollman * 944290Swollman * This library is free for commercial and non-commercial use as long as 1044290Swollman * the following conditions are aheared to. The following conditions 1144290Swollman * apply to all code found in this distribution, be it the RC4, RSA, 1244290Swollman * lhash, DES, etc., code; not just the SSL code. The SSL documentation 1344290Swollman * included with this distribution is covered by the same copyright terms 1444290Swollman * except that the holder is Tim Hudson (tjh@cryptsoft.com). 1544290Swollman * 1644290Swollman * Copyright remains Eric Young's, and as such any Copyright notices in 1744290Swollman * the code are not to be removed. 1844290Swollman * If this package is used in a product, Eric Young should be given attribution 1944290Swollman * as the author of the parts of the library used. 2044290Swollman * This can be in the form of a textual message at program startup or 2144290Swollman * in documentation (online or textual) provided with the package. 2244290Swollman * 2344290Swollman * Redistribution and use in source and binary forms, with or without 2444290Swollman * modification, are permitted provided that the following conditions 2544290Swollman * are met: 2644290Swollman * 1. Redistributions of source code must retain the copyright 2744290Swollman * notice, this list of conditions and the following disclaimer. 2844290Swollman * 2. Redistributions in binary form must reproduce the above copyright 2944290Swollman * notice, this list of conditions and the following disclaimer in the 3044290Swollman * documentation and/or other materials provided with the distribution. 3144290Swollman * 3. All advertising materials mentioning features or use of this software 3244290Swollman * must display the following acknowledgement: 3344290Swollman * "This product includes cryptographic software written by 3444290Swollman * Eric Young (eay@cryptsoft.com)" 3544290Swollman * The word 'cryptographic' can be left out if the rouines from the library 3644290Swollman * being used are not cryptographic related :-). 3744290Swollman * 4. If you include any Windows specific code (or a derivative thereof) from 3844290Swollman * the apps directory (application code) you must include an acknowledgement: 3944290Swollman * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 4044290Swollman * 4144290Swollman * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 4244290Swollman * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 4344290Swollman * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 4444290Swollman * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 4544290Swollman * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 4644290Swollman * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 4744290Swollman * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 4844290Swollman * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 4944290Swollman * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 5044290Swollman * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 5144290Swollman * SUCH DAMAGE. 5244290Swollman * 5344290Swollman * The licence and distribution terms for any publically available version or 5444290Swollman * derivative of this code cannot be changed. i.e. this code cannot simply be 5544290Swollman * copied and put under another distribution licence 5644290Swollman * [including the GNU Public Licence.] 5744290Swollman */ 5844290Swollman 5984211Sdillon#include <sys/cdefs.h> 6084211Sdillon__FBSDID("$FreeBSD: stable/10/lib/libmd/sha1c.c 314184 2017-02-23 22:10:37Z avg $"); 6184211Sdillon 6244290Swollman#include <sys/types.h> 6344290Swollman 6444290Swollman#include <stdio.h> 6544290Swollman#include <string.h> 6644290Swollman 6744290Swollman#if 0 6844290Swollman#include <machine/ansi.h> /* we use the __ variants of bit-sized types */ 6944290Swollman#endif 7044290Swollman#include <machine/endian.h> 7144290Swollman 7244290Swollman#undef SHA_0 7344290Swollman#define SHA_1 7444290Swollman#include "sha.h" 7544290Swollman#include "sha_locl.h" 7644290Swollman 7744290Swollman/* 7844290Swollman * The assembly-language code is not position-independent, so don't 7944290Swollman * try to use it in a shared library. 8044290Swollman */ 8144290Swollman#ifdef PIC 8244290Swollman#undef SHA1_ASM 8344290Swollman#endif 8444290Swollman 8544290Swollmanchar *SHA1_version="SHA1 part of SSLeay 0.9.0b 11-Oct-1998"; 8644290Swollman 8744290Swollman/* Implemented from SHA-1 document - The Secure Hash Algorithm 8844290Swollman */ 8944290Swollman 9044290Swollman#define INIT_DATA_h0 (unsigned long)0x67452301L 9144290Swollman#define INIT_DATA_h1 (unsigned long)0xefcdab89L 9244290Swollman#define INIT_DATA_h2 (unsigned long)0x98badcfeL 9344290Swollman#define INIT_DATA_h3 (unsigned long)0x10325476L 9444290Swollman#define INIT_DATA_h4 (unsigned long)0xc3d2e1f0L 9544290Swollman 9644290Swollman#define K_00_19 0x5a827999L 9744290Swollman#define K_20_39 0x6ed9eba1L 9844290Swollman#define K_40_59 0x8f1bbcdcL 9944290Swollman#define K_60_79 0xca62c1d6L 10044290Swollman 10144290Swollman#ifndef NOPROTO 10244290Swollman# ifdef SHA1_ASM 10344290Swollman void sha1_block_x86(SHA_CTX *c, const u_int32_t *p, int num); 10444290Swollman# define sha1_block sha1_block_x86 10544290Swollman# else 10644290Swollman void sha1_block(SHA_CTX *c, const u_int32_t *p, int num); 10744290Swollman# endif 10844290Swollman#else 10944290Swollman# ifdef SHA1_ASM 11044290Swollman void sha1_block_x86(); 11144290Swollman# define sha1_block sha1_block_x86 11244290Swollman# else 11344290Swollman void sha1_block(); 11444290Swollman# endif 11544290Swollman#endif 11644290Swollman 11744290Swollman 11844290Swollman#if BYTE_ORDER == LITTLE_ENDIAN && defined(SHA1_ASM) 11944290Swollman# define M_c2nl c2l 12044290Swollman# define M_p_c2nl p_c2l 12144290Swollman# define M_c2nl_p c2l_p 12244290Swollman# define M_p_c2nl_p p_c2l_p 12344290Swollman# define M_nl2c l2c 12444290Swollman#else 12544290Swollman# define M_c2nl c2nl 12644290Swollman# define M_p_c2nl p_c2nl 12744290Swollman# define M_c2nl_p c2nl_p 12844290Swollman# define M_p_c2nl_p p_c2nl_p 12944290Swollman# define M_nl2c nl2c 13044290Swollman#endif 13144290Swollman 13244290Swollmanvoid SHA1_Init(c) 13344290SwollmanSHA_CTX *c; 13444290Swollman { 13544290Swollman c->h0=INIT_DATA_h0; 13644290Swollman c->h1=INIT_DATA_h1; 13744290Swollman c->h2=INIT_DATA_h2; 13844290Swollman c->h3=INIT_DATA_h3; 13944290Swollman c->h4=INIT_DATA_h4; 14044290Swollman c->Nl=0; 14144290Swollman c->Nh=0; 14244290Swollman c->num=0; 14344290Swollman } 14444290Swollman 14544290Swollmanvoid 146154479SphkSHA1_Update(c, in, len) 14744290Swollman SHA_CTX *c; 148154479Sphk const void *in; 14944301Swollman size_t len; 15044290Swollman{ 15192913Sobrien u_int32_t *p; 15244290Swollman int ew,ec,sw,sc; 15344290Swollman u_int32_t l; 154154479Sphk const unsigned char *data = in; 15544290Swollman 15644290Swollman if (len == 0) return; 15744290Swollman 15844290Swollman l=(c->Nl+(len<<3))&0xffffffffL; 15944290Swollman if (l < c->Nl) /* overflow */ 16044290Swollman c->Nh++; 16144290Swollman c->Nh+=(len>>29); 16244290Swollman c->Nl=l; 16344290Swollman 16444290Swollman if (c->num != 0) 16544290Swollman { 16644290Swollman p=c->data; 16744290Swollman sw=c->num>>2; 16844290Swollman sc=c->num&0x03; 16944290Swollman 17044290Swollman if ((c->num+len) >= SHA_CBLOCK) 17144290Swollman { 17244290Swollman l= p[sw]; 17344290Swollman M_p_c2nl(data,l,sc); 17444290Swollman p[sw++]=l; 17544290Swollman for (; sw<SHA_LBLOCK; sw++) 17644290Swollman { 17744290Swollman M_c2nl(data,l); 17844290Swollman p[sw]=l; 17944290Swollman } 18044290Swollman len-=(SHA_CBLOCK-c->num); 18144290Swollman 18244290Swollman sha1_block(c,p,64); 18344290Swollman c->num=0; 18444290Swollman /* drop through and do the rest */ 18544290Swollman } 18644290Swollman else 18744290Swollman { 18844290Swollman c->num+=(int)len; 18944290Swollman if ((sc+len) < 4) /* ugly, add char's to a word */ 19044290Swollman { 19144290Swollman l= p[sw]; 19244290Swollman M_p_c2nl_p(data,l,sc,len); 19344290Swollman p[sw]=l; 19444290Swollman } 19544290Swollman else 19644290Swollman { 19744290Swollman ew=(c->num>>2); 19844290Swollman ec=(c->num&0x03); 19944290Swollman l= p[sw]; 20044290Swollman M_p_c2nl(data,l,sc); 20144290Swollman p[sw++]=l; 20244290Swollman for (; sw < ew; sw++) 20344290Swollman { M_c2nl(data,l); p[sw]=l; } 20444290Swollman if (ec) 20544290Swollman { 20644290Swollman M_c2nl_p(data,l,ec); 20744290Swollman p[sw]=l; 20844290Swollman } 20944290Swollman } 21044290Swollman return; 21144290Swollman } 21244290Swollman } 21344290Swollman /* We can only do the following code for assember, the reason 21444290Swollman * being that the sha1_block 'C' version changes the values 21544290Swollman * in the 'data' array. The assember code avoids this and 21644290Swollman * copies it to a local array. I should be able to do this for 21744290Swollman * the C version as well.... 21844290Swollman */ 21944290Swollman#if 1 22044290Swollman#if BYTE_ORDER == BIG_ENDIAN || defined(SHA1_ASM) 22144290Swollman if ((((unsigned int)data)%sizeof(u_int32_t)) == 0) 22244290Swollman { 22344290Swollman sw=len/SHA_CBLOCK; 22444290Swollman if (sw) 22544290Swollman { 22644290Swollman sw*=SHA_CBLOCK; 22744290Swollman sha1_block(c,(u_int32_t *)data,sw); 22844290Swollman data+=sw; 22944290Swollman len-=sw; 23044290Swollman } 23144290Swollman } 23244290Swollman#endif 23344290Swollman#endif 23444290Swollman /* we now can process the input data in blocks of SHA_CBLOCK 23544290Swollman * chars and save the leftovers to c->data. */ 23644290Swollman p=c->data; 23744290Swollman while (len >= SHA_CBLOCK) 23844290Swollman { 23944290Swollman#if BYTE_ORDER == BIG_ENDIAN || BYTE_ORDER == LITTLE_ENDIAN 24044290Swollman if (p != (u_int32_t *)data) 24144290Swollman memcpy(p,data,SHA_CBLOCK); 24244290Swollman data+=SHA_CBLOCK; 24344290Swollman# if BYTE_ORDER == LITTLE_ENDIAN 24444290Swollman# ifndef SHA1_ASM /* Will not happen */ 24544290Swollman for (sw=(SHA_LBLOCK/4); sw; sw--) 24644290Swollman { 24744290Swollman Endian_Reverse32(p[0]); 24844290Swollman Endian_Reverse32(p[1]); 24944290Swollman Endian_Reverse32(p[2]); 25044290Swollman Endian_Reverse32(p[3]); 25144290Swollman p+=4; 25244290Swollman } 25344290Swollman p=c->data; 25444290Swollman# endif 25544290Swollman# endif 25644290Swollman#else 25744290Swollman for (sw=(SHA_BLOCK/4); sw; sw--) 25844290Swollman { 25944290Swollman M_c2nl(data,l); *(p++)=l; 26044290Swollman M_c2nl(data,l); *(p++)=l; 26144290Swollman M_c2nl(data,l); *(p++)=l; 26244290Swollman M_c2nl(data,l); *(p++)=l; 26344290Swollman } 26444290Swollman p=c->data; 26544290Swollman#endif 26644290Swollman sha1_block(c,p,64); 26744290Swollman len-=SHA_CBLOCK; 26844290Swollman } 26944290Swollman ec=(int)len; 27044290Swollman c->num=ec; 27144290Swollman ew=(ec>>2); 27244290Swollman ec&=0x03; 27344290Swollman 27444290Swollman for (sw=0; sw < ew; sw++) 27544290Swollman { M_c2nl(data,l); p[sw]=l; } 27644290Swollman M_c2nl_p(data,l,ec); 27744290Swollman p[sw]=l; 27844290Swollman } 27944290Swollman 28044290Swollmanvoid SHA1_Transform(c,b) 28144290SwollmanSHA_CTX *c; 28244290Swollmanunsigned char *b; 28344290Swollman { 28444290Swollman u_int32_t p[16]; 28544290Swollman#if BYTE_ORDER != BIG_ENDIAN 28644290Swollman u_int32_t *q; 28744290Swollman int i; 28844290Swollman#endif 28944290Swollman 29044290Swollman#if BYTE_ORDER == BIG_ENDIAN || BYTE_ORDER == LITTLE_ENDIAN 29144290Swollman memcpy(p,b,64); 29244290Swollman#if BYTE_ORDER == LITTLE_ENDIAN 29344290Swollman q=p; 29444290Swollman for (i=(SHA_LBLOCK/4); i; i--) 29544290Swollman { 29644290Swollman Endian_Reverse32(q[0]); 29744290Swollman Endian_Reverse32(q[1]); 29844290Swollman Endian_Reverse32(q[2]); 29944290Swollman Endian_Reverse32(q[3]); 30044290Swollman q+=4; 30144290Swollman } 30244290Swollman#endif 30344290Swollman#else 30444290Swollman q=p; 30544290Swollman for (i=(SHA_LBLOCK/4); i; i--) 30644290Swollman { 30744290Swollman u_int32_t l; 30844290Swollman c2nl(b,l); *(q++)=l; 30944290Swollman c2nl(b,l); *(q++)=l; 31044290Swollman c2nl(b,l); *(q++)=l; 31144290Swollman c2nl(b,l); *(q++)=l; 31244290Swollman } 31344290Swollman#endif 31444290Swollman sha1_block(c,p,64); 31544290Swollman } 31644290Swollman 31744290Swollman#ifndef SHA1_ASM 31844290Swollman 31944290Swollmanvoid 32044290Swollmansha1_block(c, W, num) 32144290Swollman SHA_CTX *c; 32244290Swollman const u_int32_t *W; 32344290Swollman int num; 32444290Swollman{ 32592913Sobrien u_int32_t A,B,C,D,E,T; 32644290Swollman u_int32_t X[16]; 32744290Swollman 32844290Swollman A=c->h0; 32944290Swollman B=c->h1; 33044290Swollman C=c->h2; 33144290Swollman D=c->h3; 33244290Swollman E=c->h4; 33344290Swollman 33444290Swollman for (;;) 33544290Swollman { 33644290Swollman BODY_00_15( 0,A,B,C,D,E,T,W); 33744290Swollman BODY_00_15( 1,T,A,B,C,D,E,W); 33844290Swollman BODY_00_15( 2,E,T,A,B,C,D,W); 33944290Swollman BODY_00_15( 3,D,E,T,A,B,C,W); 34044290Swollman BODY_00_15( 4,C,D,E,T,A,B,W); 34144290Swollman BODY_00_15( 5,B,C,D,E,T,A,W); 34244290Swollman BODY_00_15( 6,A,B,C,D,E,T,W); 34344290Swollman BODY_00_15( 7,T,A,B,C,D,E,W); 34444290Swollman BODY_00_15( 8,E,T,A,B,C,D,W); 34544290Swollman BODY_00_15( 9,D,E,T,A,B,C,W); 34644290Swollman BODY_00_15(10,C,D,E,T,A,B,W); 34744290Swollman BODY_00_15(11,B,C,D,E,T,A,W); 34844290Swollman BODY_00_15(12,A,B,C,D,E,T,W); 34944290Swollman BODY_00_15(13,T,A,B,C,D,E,W); 35044290Swollman BODY_00_15(14,E,T,A,B,C,D,W); 35144290Swollman BODY_00_15(15,D,E,T,A,B,C,W); 35244290Swollman BODY_16_19(16,C,D,E,T,A,B,W,W,W,W); 35344290Swollman BODY_16_19(17,B,C,D,E,T,A,W,W,W,W); 35444290Swollman BODY_16_19(18,A,B,C,D,E,T,W,W,W,W); 35544290Swollman BODY_16_19(19,T,A,B,C,D,E,W,W,W,X); 35644290Swollman 35744290Swollman BODY_20_31(20,E,T,A,B,C,D,W,W,W,X); 35844290Swollman BODY_20_31(21,D,E,T,A,B,C,W,W,W,X); 35944290Swollman BODY_20_31(22,C,D,E,T,A,B,W,W,W,X); 36044290Swollman BODY_20_31(23,B,C,D,E,T,A,W,W,W,X); 36144290Swollman BODY_20_31(24,A,B,C,D,E,T,W,W,X,X); 36244290Swollman BODY_20_31(25,T,A,B,C,D,E,W,W,X,X); 36344290Swollman BODY_20_31(26,E,T,A,B,C,D,W,W,X,X); 36444290Swollman BODY_20_31(27,D,E,T,A,B,C,W,W,X,X); 36544290Swollman BODY_20_31(28,C,D,E,T,A,B,W,W,X,X); 36644290Swollman BODY_20_31(29,B,C,D,E,T,A,W,W,X,X); 36744290Swollman BODY_20_31(30,A,B,C,D,E,T,W,X,X,X); 36844290Swollman BODY_20_31(31,T,A,B,C,D,E,W,X,X,X); 36944290Swollman BODY_32_39(32,E,T,A,B,C,D,X); 37044290Swollman BODY_32_39(33,D,E,T,A,B,C,X); 37144290Swollman BODY_32_39(34,C,D,E,T,A,B,X); 37244290Swollman BODY_32_39(35,B,C,D,E,T,A,X); 37344290Swollman BODY_32_39(36,A,B,C,D,E,T,X); 37444290Swollman BODY_32_39(37,T,A,B,C,D,E,X); 37544290Swollman BODY_32_39(38,E,T,A,B,C,D,X); 37644290Swollman BODY_32_39(39,D,E,T,A,B,C,X); 37744290Swollman 37844290Swollman BODY_40_59(40,C,D,E,T,A,B,X); 37944290Swollman BODY_40_59(41,B,C,D,E,T,A,X); 38044290Swollman BODY_40_59(42,A,B,C,D,E,T,X); 38144290Swollman BODY_40_59(43,T,A,B,C,D,E,X); 38244290Swollman BODY_40_59(44,E,T,A,B,C,D,X); 38344290Swollman BODY_40_59(45,D,E,T,A,B,C,X); 38444290Swollman BODY_40_59(46,C,D,E,T,A,B,X); 38544290Swollman BODY_40_59(47,B,C,D,E,T,A,X); 38644290Swollman BODY_40_59(48,A,B,C,D,E,T,X); 38744290Swollman BODY_40_59(49,T,A,B,C,D,E,X); 38844290Swollman BODY_40_59(50,E,T,A,B,C,D,X); 38944290Swollman BODY_40_59(51,D,E,T,A,B,C,X); 39044290Swollman BODY_40_59(52,C,D,E,T,A,B,X); 39144290Swollman BODY_40_59(53,B,C,D,E,T,A,X); 39244290Swollman BODY_40_59(54,A,B,C,D,E,T,X); 39344290Swollman BODY_40_59(55,T,A,B,C,D,E,X); 39444290Swollman BODY_40_59(56,E,T,A,B,C,D,X); 39544290Swollman BODY_40_59(57,D,E,T,A,B,C,X); 39644290Swollman BODY_40_59(58,C,D,E,T,A,B,X); 39744290Swollman BODY_40_59(59,B,C,D,E,T,A,X); 39844290Swollman 39944290Swollman BODY_60_79(60,A,B,C,D,E,T,X); 40044290Swollman BODY_60_79(61,T,A,B,C,D,E,X); 40144290Swollman BODY_60_79(62,E,T,A,B,C,D,X); 40244290Swollman BODY_60_79(63,D,E,T,A,B,C,X); 40344290Swollman BODY_60_79(64,C,D,E,T,A,B,X); 40444290Swollman BODY_60_79(65,B,C,D,E,T,A,X); 40544290Swollman BODY_60_79(66,A,B,C,D,E,T,X); 40644290Swollman BODY_60_79(67,T,A,B,C,D,E,X); 40744290Swollman BODY_60_79(68,E,T,A,B,C,D,X); 40844290Swollman BODY_60_79(69,D,E,T,A,B,C,X); 40944290Swollman BODY_60_79(70,C,D,E,T,A,B,X); 41044290Swollman BODY_60_79(71,B,C,D,E,T,A,X); 41144290Swollman BODY_60_79(72,A,B,C,D,E,T,X); 41244290Swollman BODY_60_79(73,T,A,B,C,D,E,X); 41344290Swollman BODY_60_79(74,E,T,A,B,C,D,X); 41444290Swollman BODY_60_79(75,D,E,T,A,B,C,X); 41544290Swollman BODY_60_79(76,C,D,E,T,A,B,X); 41644290Swollman BODY_60_79(77,B,C,D,E,T,A,X); 41744290Swollman BODY_60_79(78,A,B,C,D,E,T,X); 41844290Swollman BODY_60_79(79,T,A,B,C,D,E,X); 41944290Swollman 42044290Swollman c->h0=(c->h0+E)&0xffffffffL; 42144290Swollman c->h1=(c->h1+T)&0xffffffffL; 42244290Swollman c->h2=(c->h2+A)&0xffffffffL; 42344290Swollman c->h3=(c->h3+B)&0xffffffffL; 42444290Swollman c->h4=(c->h4+C)&0xffffffffL; 42544290Swollman 42644290Swollman num-=64; 42744290Swollman if (num <= 0) break; 42844290Swollman 42944290Swollman A=c->h0; 43044290Swollman B=c->h1; 43144290Swollman C=c->h2; 43244290Swollman D=c->h3; 43344290Swollman E=c->h4; 43444290Swollman 43544290Swollman W+=16; 43644290Swollman } 43744290Swollman } 43844290Swollman#endif 43944290Swollman 44044290Swollmanvoid SHA1_Final(md, c) 44144290Swollmanunsigned char *md; 44244290SwollmanSHA_CTX *c; 44344290Swollman { 44492913Sobrien int i,j; 44592913Sobrien u_int32_t l; 44692913Sobrien u_int32_t *p; 44744290Swollman static unsigned char end[4]={0x80,0x00,0x00,0x00}; 44844290Swollman unsigned char *cp=end; 44944290Swollman 45044290Swollman /* c->num should definitly have room for at least one more byte. */ 45144290Swollman p=c->data; 45244290Swollman j=c->num; 45344290Swollman i=j>>2; 45444290Swollman#ifdef PURIFY 45544290Swollman if ((j&0x03) == 0) p[i]=0; 45644290Swollman#endif 45744290Swollman l=p[i]; 45844290Swollman M_p_c2nl(cp,l,j&0x03); 45944290Swollman p[i]=l; 46044290Swollman i++; 46144290Swollman /* i is the next 'undefined word' */ 46244290Swollman if (c->num >= SHA_LAST_BLOCK) 46344290Swollman { 46444290Swollman for (; i<SHA_LBLOCK; i++) 46544290Swollman p[i]=0; 46644290Swollman sha1_block(c,p,64); 46744290Swollman i=0; 46844290Swollman } 46944290Swollman for (; i<(SHA_LBLOCK-2); i++) 47044290Swollman p[i]=0; 47144290Swollman p[SHA_LBLOCK-2]=c->Nh; 47244290Swollman p[SHA_LBLOCK-1]=c->Nl; 47344290Swollman#if BYTE_ORDER == LITTLE_ENDIAN && defined(SHA1_ASM) 47444290Swollman Endian_Reverse32(p[SHA_LBLOCK-2]); 47544290Swollman Endian_Reverse32(p[SHA_LBLOCK-1]); 47644290Swollman#endif 47744290Swollman sha1_block(c,p,64); 47844290Swollman cp=md; 47944290Swollman l=c->h0; nl2c(l,cp); 48044290Swollman l=c->h1; nl2c(l,cp); 48144290Swollman l=c->h2; nl2c(l,cp); 48244290Swollman l=c->h3; nl2c(l,cp); 48344290Swollman l=c->h4; nl2c(l,cp); 48444290Swollman 48544290Swollman /* clear stuff, sha1_block may be leaving some stuff on the stack 48644290Swollman * but I'm not worried :-) */ 48744290Swollman c->num=0; 48844290Swollman/* memset((char *)&c,0,sizeof(c));*/ 48944290Swollman } 49044290Swollman 491314184Savg#ifdef WEAK_REFS 492314184Savg/* When building libmd, provide weak references. Note: this is not 493314184Savg activated in the context of compiling these sources for internal 494314184Savg use in libcrypt. 495314184Savg */ 496314144Savg#undef SHA_Init 497314144Savg__weak_reference(_libmd_SHA_Init, SHA_Init); 498314144Savg#undef SHA_Update 499314144Savg__weak_reference(_libmd_SHA_Update, SHA_Update); 500314144Savg#undef SHA_Final 501314144Savg__weak_reference(_libmd_SHA_Final, SHA_Final); 502314144Savg#undef SHA_Transform 503314144Savg__weak_reference(_libmd_SHA_Transform, SHA_Transform); 504314144Savg#undef SHA_version 505314144Savg__weak_reference(_libmd_SHA_version, SHA_version); 506314144Savg#undef sha_block 507314144Savg__weak_reference(_libmd_sha_block, sha_block); 508314144Savg#undef SHA1_Init 509314144Savg__weak_reference(_libmd_SHA1_Init, SHA1_Init); 510314144Savg#undef SHA1_Update 511314144Savg__weak_reference(_libmd_SHA1_Update, SHA1_Update); 512314144Savg#undef SHA1_Final 513314144Savg__weak_reference(_libmd_SHA1_Final, SHA1_Final); 514314144Savg#undef SHA1_Transform 515314144Savg__weak_reference(_libmd_SHA1_Transform, SHA1_Transform); 516314144Savg#undef SHA1_version 517314144Savg__weak_reference(_libmd_SHA1_version, SHA1_version); 518314144Savg#undef sha1_block 519314144Savg__weak_reference(_libmd_sha1_block, sha1_block); 520314184Savg#endif 521