Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/ssh/lib/../blocks.c	Lines:	146	146	100.0 %
Date:	2017-11-07	Branches:	2	2	100.0 %


/* $OpenBSD: blocks.c,v 1.3 2013/12/09 11:03:45 markus Exp $ */

/*
 * Public Domain, Author: Daniel J. Bernstein
 * Copied from nacl-20110221/crypto_hashblocks/sha512/ref/blocks.c
 */

#include "crypto_api.h"

typedef unsigned long long uint64;

static uint64 load_bigendian(const unsigned char *x)
{
  return
      (uint64) (x[7]) \
  | (((uint64) (x[6])) << 8) \
  | (((uint64) (x[5])) << 16) \
  | (((uint64) (x[4])) << 24) \
  | (((uint64) (x[3])) << 32) \
  | (((uint64) (x[2])) << 40) \
  | (((uint64) (x[1])) << 48) \
  | (((uint64) (x[0])) << 56)
  ;
}

static void store_bigendian(unsigned char *x,uint64 u)
{
  x[7] = u; u >>= 8;
  x[6] = u; u >>= 8;
  x[5] = u; u >>= 8;
  x[4] = u; u >>= 8;
  x[3] = u; u >>= 8;
  x[2] = u; u >>= 8;
  x[1] = u; u >>= 8;
  x[0] = u;
}

#define SHR(x,c) ((x) >> (c))
#define ROTR(x,c) (((x) >> (c)) | ((x) << (64 - (c))))

#define Ch(x,y,z) ((x & y) ^ (~x & z))
#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
#define Sigma0(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
#define Sigma1(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
#define sigma0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x,7))
#define sigma1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x,6))

#define M(w0,w14,w9,w1) w0 = sigma1(w14) + w9 + sigma0(w1) + w0;

#define EXPAND \
  M(w0 ,w14,w9 ,w1 ) \
  M(w1 ,w15,w10,w2 ) \
  M(w2 ,w0 ,w11,w3 ) \
  M(w3 ,w1 ,w12,w4 ) \
  M(w4 ,w2 ,w13,w5 ) \
  M(w5 ,w3 ,w14,w6 ) \
  M(w6 ,w4 ,w15,w7 ) \
  M(w7 ,w5 ,w0 ,w8 ) \
  M(w8 ,w6 ,w1 ,w9 ) \
  M(w9 ,w7 ,w2 ,w10) \
  M(w10,w8 ,w3 ,w11) \
  M(w11,w9 ,w4 ,w12) \
  M(w12,w10,w5 ,w13) \
  M(w13,w11,w6 ,w14) \
  M(w14,w12,w7 ,w15) \
  M(w15,w13,w8 ,w0 )

#define F(w,k) \
  T1 = h + Sigma1(e) + Ch(e,f,g) + k + w; \
  T2 = Sigma0(a) + Maj(a,b,c); \
  h = g; \
  g = f; \
  f = e; \
  e = d + T1; \
  d = c; \
  c = b; \
  b = a; \
  a = T1 + T2;

int crypto_hashblocks_sha512(unsigned char *statebytes,const unsigned char *in,unsigned long long inlen)
{
  uint64 state[8];
  uint64 a;
  uint64 b;
  uint64 c;
  uint64 d;
  uint64 e;
  uint64 f;
  uint64 g;
  uint64 h;
  uint64 T1;
  uint64 T2;

  a = load_bigendian(statebytes +  0); state[0] = a;
  b = load_bigendian(statebytes +  8); state[1] = b;
  c = load_bigendian(statebytes + 16); state[2] = c;
  d = load_bigendian(statebytes + 24); state[3] = d;
  e = load_bigendian(statebytes + 32); state[4] = e;
  f = load_bigendian(statebytes + 40); state[5] = f;
  g = load_bigendian(statebytes + 48); state[6] = g;
  h = load_bigendian(statebytes + 56); state[7] = h;

  while (inlen >= 128) {
    uint64 w0  = load_bigendian(in +   0);
    uint64 w1  = load_bigendian(in +   8);
    uint64 w2  = load_bigendian(in +  16);
    uint64 w3  = load_bigendian(in +  24);
    uint64 w4  = load_bigendian(in +  32);
    uint64 w5  = load_bigendian(in +  40);
    uint64 w6  = load_bigendian(in +  48);
    uint64 w7  = load_bigendian(in +  56);
    uint64 w8  = load_bigendian(in +  64);
    uint64 w9  = load_bigendian(in +  72);
    uint64 w10 = load_bigendian(in +  80);
    uint64 w11 = load_bigendian(in +  88);
    uint64 w12 = load_bigendian(in +  96);
    uint64 w13 = load_bigendian(in + 104);
    uint64 w14 = load_bigendian(in + 112);
    uint64 w15 = load_bigendian(in + 120);

    F(w0 ,0x428a2f98d728ae22ULL)
    F(w1 ,0x7137449123ef65cdULL)
    F(w2 ,0xb5c0fbcfec4d3b2fULL)
    F(w3 ,0xe9b5dba58189dbbcULL)
    F(w4 ,0x3956c25bf348b538ULL)
    F(w5 ,0x59f111f1b605d019ULL)
    F(w6 ,0x923f82a4af194f9bULL)
    F(w7 ,0xab1c5ed5da6d8118ULL)
    F(w8 ,0xd807aa98a3030242ULL)
    F(w9 ,0x12835b0145706fbeULL)
    F(w10,0x243185be4ee4b28cULL)
    F(w11,0x550c7dc3d5ffb4e2ULL)
    F(w12,0x72be5d74f27b896fULL)
    F(w13,0x80deb1fe3b1696b1ULL)
    F(w14,0x9bdc06a725c71235ULL)
    F(w15,0xc19bf174cf692694ULL)

    EXPAND

    F(w0 ,0xe49b69c19ef14ad2ULL)
    F(w1 ,0xefbe4786384f25e3ULL)
    F(w2 ,0x0fc19dc68b8cd5b5ULL)
    F(w3 ,0x240ca1cc77ac9c65ULL)
    F(w4 ,0x2de92c6f592b0275ULL)
    F(w5 ,0x4a7484aa6ea6e483ULL)
    F(w6 ,0x5cb0a9dcbd41fbd4ULL)
    F(w7 ,0x76f988da831153b5ULL)
    F(w8 ,0x983e5152ee66dfabULL)
    F(w9 ,0xa831c66d2db43210ULL)
    F(w10,0xb00327c898fb213fULL)
    F(w11,0xbf597fc7beef0ee4ULL)
    F(w12,0xc6e00bf33da88fc2ULL)
    F(w13,0xd5a79147930aa725ULL)
    F(w14,0x06ca6351e003826fULL)
    F(w15,0x142929670a0e6e70ULL)

    EXPAND

    F(w0 ,0x27b70a8546d22ffcULL)
    F(w1 ,0x2e1b21385c26c926ULL)
    F(w2 ,0x4d2c6dfc5ac42aedULL)
    F(w3 ,0x53380d139d95b3dfULL)
    F(w4 ,0x650a73548baf63deULL)
    F(w5 ,0x766a0abb3c77b2a8ULL)
    F(w6 ,0x81c2c92e47edaee6ULL)
    F(w7 ,0x92722c851482353bULL)
    F(w8 ,0xa2bfe8a14cf10364ULL)
    F(w9 ,0xa81a664bbc423001ULL)
    F(w10,0xc24b8b70d0f89791ULL)
    F(w11,0xc76c51a30654be30ULL)
    F(w12,0xd192e819d6ef5218ULL)
    F(w13,0xd69906245565a910ULL)
    F(w14,0xf40e35855771202aULL)
    F(w15,0x106aa07032bbd1b8ULL)

    EXPAND

    F(w0 ,0x19a4c116b8d2d0c8ULL)
    F(w1 ,0x1e376c085141ab53ULL)
    F(w2 ,0x2748774cdf8eeb99ULL)
    F(w3 ,0x34b0bcb5e19b48a8ULL)
    F(w4 ,0x391c0cb3c5c95a63ULL)
    F(w5 ,0x4ed8aa4ae3418acbULL)
    F(w6 ,0x5b9cca4f7763e373ULL)
    F(w7 ,0x682e6ff3d6b2b8a3ULL)
    F(w8 ,0x748f82ee5defb2fcULL)
    F(w9 ,0x78a5636f43172f60ULL)
    F(w10,0x84c87814a1f0ab72ULL)
    F(w11,0x8cc702081a6439ecULL)
    F(w12,0x90befffa23631e28ULL)
    F(w13,0xa4506cebde82bde9ULL)
    F(w14,0xbef9a3f7b2c67915ULL)
    F(w15,0xc67178f2e372532bULL)

    EXPAND

    F(w0 ,0xca273eceea26619cULL)
    F(w1 ,0xd186b8c721c0c207ULL)
    F(w2 ,0xeada7dd6cde0eb1eULL)
    F(w3 ,0xf57d4f7fee6ed178ULL)
    F(w4 ,0x06f067aa72176fbaULL)
    F(w5 ,0x0a637dc5a2c898a6ULL)
    F(w6 ,0x113f9804bef90daeULL)
    F(w7 ,0x1b710b35131c471bULL)
    F(w8 ,0x28db77f523047d84ULL)
    F(w9 ,0x32caab7b40c72493ULL)
    F(w10,0x3c9ebe0a15c9bebcULL)
    F(w11,0x431d67c49c100d4cULL)
    F(w12,0x4cc5d4becb3e42b6ULL)
    F(w13,0x597f299cfc657e2aULL)
    F(w14,0x5fcb6fab3ad6faecULL)
    F(w15,0x6c44198c4a475817ULL)

    a += state[0];
    b += state[1];
    c += state[2];
    d += state[3];
    e += state[4];
    f += state[5];
    g += state[6];
    h += state[7];

    state[0] = a;
    state[1] = b;
    state[2] = c;
    state[3] = d;
    state[4] = e;
    state[5] = f;
    state[6] = g;
    state[7] = h;

    in += 128;
    inlen -= 128;
  }

  store_bigendian(statebytes +  0,state[0]);
  store_bigendian(statebytes +  8,state[1]);
  store_bigendian(statebytes + 16,state[2]);
  store_bigendian(statebytes + 24,state[3]);
  store_bigendian(statebytes + 32,state[4]);
  store_bigendian(statebytes + 40,state[5]);
  store_bigendian(statebytes + 48,state[6]);
  store_bigendian(statebytes + 56,state[7]);

  return inlen;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: blocks.c,v 1.3 2013/12/09 11:03:45 markus Exp $ */
2
3			/*
4			* Public Domain, Author: Daniel J. Bernstein
5			* Copied from nacl-20110221/crypto_hashblocks/sha512/ref/blocks.c
6			*/
7
8			#include "crypto_api.h"
9
10			typedef unsigned long long uint64;
11
12			static uint64 load_bigendian(const unsigned char *x)
13			{
14		160	return
15		320	(uint64) (x[7]) \
16		160	\| (((uint64) (x[6])) << 8) \
17		160	\| (((uint64) (x[5])) << 16) \
18		160	\| (((uint64) (x[4])) << 24) \
19		160	\| (((uint64) (x[3])) << 32) \
20		160	\| (((uint64) (x[2])) << 40) \
21		160	\| (((uint64) (x[1])) << 48) \
22		160	\| (((uint64) (x[0])) << 56)
23			;
24			}
25
26			static void store_bigendian(unsigned char *x,uint64 u)
27			{
28		160	x[7] = u; u >>= 8;
29		80	x[6] = u; u >>= 8;
30		80	x[5] = u; u >>= 8;
31		80	x[4] = u; u >>= 8;
32		80	x[3] = u; u >>= 8;
33		80	x[2] = u; u >>= 8;
34		80	x[1] = u; u >>= 8;
35		80	x[0] = u;
36		80	}
37
38			#define SHR(x,c) ((x) >> (c))
39			#define ROTR(x,c) (((x) >> (c)) \| ((x) << (64 - (c))))
40
41			#define Ch(x,y,z) ((x & y) ^ (~x & z))
42			#define Maj(x,y,z) ((x & y) ^ (x & z) ^ (y & z))
43			#define Sigma0(x) (ROTR(x,28) ^ ROTR(x,34) ^ ROTR(x,39))
44			#define Sigma1(x) (ROTR(x,14) ^ ROTR(x,18) ^ ROTR(x,41))
45			#define sigma0(x) (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x,7))
46			#define sigma1(x) (ROTR(x,19) ^ ROTR(x,61) ^ SHR(x,6))
47
48			#define M(w0,w14,w9,w1) w0 = sigma1(w14) + w9 + sigma0(w1) + w0;
49
50			#define EXPAND \
51			M(w0 ,w14,w9 ,w1 ) \
52			M(w1 ,w15,w10,w2 ) \
53			M(w2 ,w0 ,w11,w3 ) \
54			M(w3 ,w1 ,w12,w4 ) \
55			M(w4 ,w2 ,w13,w5 ) \
56			M(w5 ,w3 ,w14,w6 ) \
57			M(w6 ,w4 ,w15,w7 ) \
58			M(w7 ,w5 ,w0 ,w8 ) \
59			M(w8 ,w6 ,w1 ,w9 ) \
60			M(w9 ,w7 ,w2 ,w10) \
61			M(w10,w8 ,w3 ,w11) \
62			M(w11,w9 ,w4 ,w12) \
63			M(w12,w10,w5 ,w13) \
64			M(w13,w11,w6 ,w14) \
65			M(w14,w12,w7 ,w15) \
66			M(w15,w13,w8 ,w0 )
67
68			#define F(w,k) \
69			T1 = h + Sigma1(e) + Ch(e,f,g) + k + w; \
70			T2 = Sigma0(a) + Maj(a,b,c); \
71			h = g; \
72			g = f; \
73			f = e; \
74			e = d + T1; \
75			d = c; \
76			c = b; \
77			b = a; \
78			a = T1 + T2;
79
80			int crypto_hashblocks_sha512(unsigned char statebytes,const unsigned char in,unsigned long long inlen)
81			{
82			uint64 state[8];
83			uint64 a;
84			uint64 b;
85			uint64 c;
86			uint64 d;
87			uint64 e;
88			uint64 f;
89			uint64 g;
90			uint64 h;
91			uint64 T1;
92			uint64 T2;
93
94		20	a = load_bigendian(statebytes + 0); state[0] = a;
95		10	b = load_bigendian(statebytes + 8); state[1] = b;
96		10	c = load_bigendian(statebytes + 16); state[2] = c;
97		10	d = load_bigendian(statebytes + 24); state[3] = d;
98		10	e = load_bigendian(statebytes + 32); state[4] = e;
99		10	f = load_bigendian(statebytes + 40); state[5] = f;
100		10	g = load_bigendian(statebytes + 48); state[6] = g;
101		10	h = load_bigendian(statebytes + 56); state[7] = h;
102
103	✓✓	30	while (inlen >= 128) {
104		5	uint64 w0 = load_bigendian(in + 0);
105		5	uint64 w1 = load_bigendian(in + 8);
106		5	uint64 w2 = load_bigendian(in + 16);
107		5	uint64 w3 = load_bigendian(in + 24);
108		5	uint64 w4 = load_bigendian(in + 32);
109		5	uint64 w5 = load_bigendian(in + 40);
110		5	uint64 w6 = load_bigendian(in + 48);
111		5	uint64 w7 = load_bigendian(in + 56);
112		5	uint64 w8 = load_bigendian(in + 64);
113		5	uint64 w9 = load_bigendian(in + 72);
114		5	uint64 w10 = load_bigendian(in + 80);
115		5	uint64 w11 = load_bigendian(in + 88);
116		5	uint64 w12 = load_bigendian(in + 96);
117		5	uint64 w13 = load_bigendian(in + 104);
118		5	uint64 w14 = load_bigendian(in + 112);
119		5	uint64 w15 = load_bigendian(in + 120);
120
121		5	F(w0 ,0x428a2f98d728ae22ULL)
122		5	F(w1 ,0x7137449123ef65cdULL)
123		5	F(w2 ,0xb5c0fbcfec4d3b2fULL)
124		5	F(w3 ,0xe9b5dba58189dbbcULL)
125		5	F(w4 ,0x3956c25bf348b538ULL)
126		5	F(w5 ,0x59f111f1b605d019ULL)
127		5	F(w6 ,0x923f82a4af194f9bULL)
128		5	F(w7 ,0xab1c5ed5da6d8118ULL)
129		5	F(w8 ,0xd807aa98a3030242ULL)
130		5	F(w9 ,0x12835b0145706fbeULL)
131		5	F(w10,0x243185be4ee4b28cULL)
132		5	F(w11,0x550c7dc3d5ffb4e2ULL)
133		5	F(w12,0x72be5d74f27b896fULL)
134		5	F(w13,0x80deb1fe3b1696b1ULL)
135		5	F(w14,0x9bdc06a725c71235ULL)
136		5	F(w15,0xc19bf174cf692694ULL)
137
138		5	EXPAND
139
140		5	F(w0 ,0xe49b69c19ef14ad2ULL)
141		5	F(w1 ,0xefbe4786384f25e3ULL)
142		5	F(w2 ,0x0fc19dc68b8cd5b5ULL)
143		5	F(w3 ,0x240ca1cc77ac9c65ULL)
144		5	F(w4 ,0x2de92c6f592b0275ULL)
145		5	F(w5 ,0x4a7484aa6ea6e483ULL)
146		5	F(w6 ,0x5cb0a9dcbd41fbd4ULL)
147		5	F(w7 ,0x76f988da831153b5ULL)
148		5	F(w8 ,0x983e5152ee66dfabULL)
149		5	F(w9 ,0xa831c66d2db43210ULL)
150		5	F(w10,0xb00327c898fb213fULL)
151		5	F(w11,0xbf597fc7beef0ee4ULL)
152		5	F(w12,0xc6e00bf33da88fc2ULL)
153		5	F(w13,0xd5a79147930aa725ULL)
154		5	F(w14,0x06ca6351e003826fULL)
155		5	F(w15,0x142929670a0e6e70ULL)
156
157		5	EXPAND
158
159		5	F(w0 ,0x27b70a8546d22ffcULL)
160		5	F(w1 ,0x2e1b21385c26c926ULL)
161		5	F(w2 ,0x4d2c6dfc5ac42aedULL)
162		5	F(w3 ,0x53380d139d95b3dfULL)
163		5	F(w4 ,0x650a73548baf63deULL)
164		5	F(w5 ,0x766a0abb3c77b2a8ULL)
165		5	F(w6 ,0x81c2c92e47edaee6ULL)
166		5	F(w7 ,0x92722c851482353bULL)
167		5	F(w8 ,0xa2bfe8a14cf10364ULL)
168		5	F(w9 ,0xa81a664bbc423001ULL)
169		5	F(w10,0xc24b8b70d0f89791ULL)
170		5	F(w11,0xc76c51a30654be30ULL)
171		5	F(w12,0xd192e819d6ef5218ULL)
172		5	F(w13,0xd69906245565a910ULL)
173		5	F(w14,0xf40e35855771202aULL)
174		5	F(w15,0x106aa07032bbd1b8ULL)
175
176		5	EXPAND
177
178		5	F(w0 ,0x19a4c116b8d2d0c8ULL)
179		5	F(w1 ,0x1e376c085141ab53ULL)
180		5	F(w2 ,0x2748774cdf8eeb99ULL)
181		5	F(w3 ,0x34b0bcb5e19b48a8ULL)
182		5	F(w4 ,0x391c0cb3c5c95a63ULL)
183		5	F(w5 ,0x4ed8aa4ae3418acbULL)
184		5	F(w6 ,0x5b9cca4f7763e373ULL)
185		5	F(w7 ,0x682e6ff3d6b2b8a3ULL)
186		5	F(w8 ,0x748f82ee5defb2fcULL)
187		5	F(w9 ,0x78a5636f43172f60ULL)
188		5	F(w10,0x84c87814a1f0ab72ULL)
189		5	F(w11,0x8cc702081a6439ecULL)
190		5	F(w12,0x90befffa23631e28ULL)
191		5	F(w13,0xa4506cebde82bde9ULL)
192		5	F(w14,0xbef9a3f7b2c67915ULL)
193		5	F(w15,0xc67178f2e372532bULL)
194
195		5	EXPAND
196
197		5	F(w0 ,0xca273eceea26619cULL)
198		5	F(w1 ,0xd186b8c721c0c207ULL)
199		5	F(w2 ,0xeada7dd6cde0eb1eULL)
200		5	F(w3 ,0xf57d4f7fee6ed178ULL)
201		5	F(w4 ,0x06f067aa72176fbaULL)
202		5	F(w5 ,0x0a637dc5a2c898a6ULL)
203		5	F(w6 ,0x113f9804bef90daeULL)
204		5	F(w7 ,0x1b710b35131c471bULL)
205		5	F(w8 ,0x28db77f523047d84ULL)
206		5	F(w9 ,0x32caab7b40c72493ULL)
207		5	F(w10,0x3c9ebe0a15c9bebcULL)
208		5	F(w11,0x431d67c49c100d4cULL)
209		5	F(w12,0x4cc5d4becb3e42b6ULL)
210		5	F(w13,0x597f299cfc657e2aULL)
211		5	F(w14,0x5fcb6fab3ad6faecULL)
212		5	F(w15,0x6c44198c4a475817ULL)
213
214		5	a += state[0];
215		5	b += state[1];
216		5	c += state[2];
217		5	d += state[3];
218		5	e += state[4];
219		5	f += state[5];
220		5	g += state[6];
221		5	h += state[7];
222
223			state[0] = a;
224			state[1] = b;
225			state[2] = c;
226			state[3] = d;
227			state[4] = e;
228			state[5] = f;
229			state[6] = g;
230			state[7] = h;
231
232		5	in += 128;
233		5	inlen -= 128;
234			}
235
236		10	store_bigendian(statebytes + 0,state[0]);
237		10	store_bigendian(statebytes + 8,state[1]);
238		10	store_bigendian(statebytes + 16,state[2]);
239		10	store_bigendian(statebytes + 24,state[3]);
240		10	store_bigendian(statebytes + 32,state[4]);
241		10	store_bigendian(statebytes + 40,state[5]);
242		10	store_bigendian(statebytes + 48,state[6]);
243		10	store_bigendian(statebytes + 56,state[7]);
244
245		10	return inlen;
246			}