/src/openssl30/crypto/bn/bn_add.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include "internal/cryptlib.h"
#include "bn_local.h"

/* signed add of b to a. */
int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
{
    int ret, r_neg, cmp_res;

    bn_check_top(a);
    bn_check_top(b);

    if (a->neg == b->neg) {
        r_neg = a->neg;
        ret = BN_uadd(r, a, b);
    } else {
        cmp_res = BN_ucmp(a, b);
        if (cmp_res > 0) {
            r_neg = a->neg;
            ret = BN_usub(r, a, b);
        } else if (cmp_res < 0) {
            r_neg = b->neg;
            ret = BN_usub(r, b, a);
        } else {
            r_neg = 0;
            BN_zero(r);
            ret = 1;
        }
    }

    r->neg = r_neg;
    bn_check_top(r);
    return ret;
}

/* signed sub of b from a. */
int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
{
    int ret, r_neg, cmp_res;

    bn_check_top(a);
    bn_check_top(b);

    if (a->neg != b->neg) {
        r_neg = a->neg;
        ret = BN_uadd(r, a, b);
    } else {
        cmp_res = BN_ucmp(a, b);
        if (cmp_res > 0) {
            r_neg = a->neg;
            ret = BN_usub(r, a, b);
        } else if (cmp_res < 0) {
            r_neg = !b->neg;
            ret = BN_usub(r, b, a);
        } else {
            r_neg = 0;
            BN_zero(r);
            ret = 1;
        }
    }

    r->neg = r_neg;
    bn_check_top(r);
    return ret;
}

/* unsigned add of b to a, r can be equal to a or b. */
int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
{
    int max, min, dif;
    const BN_ULONG *ap, *bp;
    BN_ULONG *rp, carry, t1, t2;

    bn_check_top(a);
    bn_check_top(b);

    if (a->top < b->top) {
        const BIGNUM *tmp;

        tmp = a;
        a = b;
        b = tmp;
    }
    max = a->top;
    min = b->top;
    dif = max - min;

    if (bn_wexpand(r, max + 1) == NULL)
        return 0;

    r->top = max;

    ap = a->d;
    bp = b->d;
    rp = r->d;

    carry = bn_add_words(rp, ap, bp, min);
    rp += min;
    ap += min;

    while (dif) {
        dif--;
        t1 = *(ap++);
        t2 = (t1 + carry) & BN_MASK2;
        *(rp++) = t2;
        carry &= (t2 == 0);
    }
    *rp = carry;
    r->top += carry;

    r->neg = 0;
    bn_check_top(r);
    return 1;
}

/* unsigned subtraction of b from a, a must be larger than b. */
int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)
{
    int max, min, dif;
    BN_ULONG t1, t2, borrow, *rp;
    const BN_ULONG *ap, *bp;

    bn_check_top(a);
    bn_check_top(b);

    max = a->top;
    min = b->top;
    dif = max - min;

    if (dif < 0) {              /* hmm... should not be happening */
        ERR_raise(ERR_LIB_BN, BN_R_ARG2_LT_ARG3);
        return 0;
    }

    if (bn_wexpand(r, max) == NULL)
        return 0;

    ap = a->d;
    bp = b->d;
    rp = r->d;

    borrow = bn_sub_words(rp, ap, bp, min);
    ap += min;
    rp += min;

    while (dif) {
        dif--;
        t1 = *(ap++);
        t2 = (t1 - borrow) & BN_MASK2;
        *(rp++) = t2;
        borrow &= (t1 == 0);
    }

    while (max && *--rp == 0)
        max--;

    r->top = max;
    r->neg = 0;
    bn_pollute(r);

    return 1;
}


Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10		#include "internal/cryptlib.h"
11		#include "bn_local.h"
12
13		/* signed add of b to a. */
14		int BN_add(BIGNUM r, const BIGNUM a, const BIGNUM *b)
15	2.74k	{
16	2.74k	int ret, r_neg, cmp_res;
17
18	2.74k	bn_check_top(a);
19	2.74k	bn_check_top(b);
20
21	2.74k	if (a->neg == b->neg) {
22	2.39k	r_neg = a->neg;
23	2.39k	ret = BN_uadd(r, a, b);
24	2.39k	} else {
25	345	cmp_res = BN_ucmp(a, b);
26	345	if (cmp_res > 0) {
27	206	r_neg = a->neg;
28	206	ret = BN_usub(r, a, b);
29	206	} else if (cmp_res < 0) {
30	139	r_neg = b->neg;
31	139	ret = BN_usub(r, b, a);
32	139	} else {
33	0	r_neg = 0;
34	0	BN_zero(r);
35	0	ret = 1;
36	0	}
37	345	}
38
39	2.74k	r->neg = r_neg;
40	2.74k	bn_check_top(r);
41	2.74k	return ret;
42	2.74k	}
43
44		/* signed sub of b from a. */
45		int BN_sub(BIGNUM r, const BIGNUM a, const BIGNUM *b)
46	0	{
47	0	int ret, r_neg, cmp_res;
48
49	0	bn_check_top(a);
50	0	bn_check_top(b);
51
52	0	if (a->neg != b->neg) {
53	0	r_neg = a->neg;
54	0	ret = BN_uadd(r, a, b);
55	0	} else {
56	0	cmp_res = BN_ucmp(a, b);
57	0	if (cmp_res > 0) {
58	0	r_neg = a->neg;
59	0	ret = BN_usub(r, a, b);
60	0	} else if (cmp_res < 0) {
61	0	r_neg = !b->neg;
62	0	ret = BN_usub(r, b, a);
63	0	} else {
64	0	r_neg = 0;
65	0	BN_zero(r);
66	0	ret = 1;
67	0	}
68	0	}
69
70	0	r->neg = r_neg;
71	0	bn_check_top(r);
72	0	return ret;
73	0	}
74
75		/* unsigned add of b to a, r can be equal to a or b. */
76		int BN_uadd(BIGNUM r, const BIGNUM a, const BIGNUM *b)
77	2.39k	{
78	2.39k	int max, min, dif;
79	2.39k	const BN_ULONG ap, bp;
80	2.39k	BN_ULONG *rp, carry, t1, t2;
81
82	2.39k	bn_check_top(a);
83	2.39k	bn_check_top(b);
84
85	2.39k	if (a->top < b->top) {
86	43	const BIGNUM *tmp;
87
88	43	tmp = a;
89	43	a = b;
90	43	b = tmp;
91	43	}
92	2.39k	max = a->top;
93	2.39k	min = b->top;
94	2.39k	dif = max - min;
95
96	2.39k	if (bn_wexpand(r, max + 1) == NULL)
97	0	return 0;
98
99	2.39k	r->top = max;
100
101	2.39k	ap = a->d;
102	2.39k	bp = b->d;
103	2.39k	rp = r->d;
104
105	2.39k	carry = bn_add_words(rp, ap, bp, min);
106	2.39k	rp += min;
107	2.39k	ap += min;
108
109	1.08M	while (dif) {
110	1.08M	dif--;
111	1.08M	t1 = *(ap++);
112	1.08M	t2 = (t1 + carry) & BN_MASK2;
113	1.08M	*(rp++) = t2;
114	1.08M	carry &= (t2 == 0);
115	1.08M	}
116	2.39k	*rp = carry;
117	2.39k	r->top += carry;
118
119	2.39k	r->neg = 0;
120	2.39k	bn_check_top(r);
121	2.39k	return 1;
122	2.39k	}
123
124		/* unsigned subtraction of b from a, a must be larger than b. */
125		int BN_usub(BIGNUM r, const BIGNUM a, const BIGNUM *b)
126	345	{
127	345	int max, min, dif;
128	345	BN_ULONG t1, t2, borrow, *rp;
129	345	const BN_ULONG ap, bp;
130
131	345	bn_check_top(a);
132	345	bn_check_top(b);
133
134	345	max = a->top;
135	345	min = b->top;
136	345	dif = max - min;
137
138	345	if (dif < 0) { /* hmm... should not be happening */
139	0	ERR_raise(ERR_LIB_BN, BN_R_ARG2_LT_ARG3);
140	0	return 0;
141	0	}
142
143	345	if (bn_wexpand(r, max) == NULL)
144	0	return 0;
145
146	345	ap = a->d;
147	345	bp = b->d;
148	345	rp = r->d;
149
150	345	borrow = bn_sub_words(rp, ap, bp, min);
151	345	ap += min;
152	345	rp += min;
153
154	156k	while (dif) {
155	156k	dif--;
156	156k	t1 = *(ap++);
157	156k	t2 = (t1 - borrow) & BN_MASK2;
158	156k	*(rp++) = t2;
159	156k	borrow &= (t1 == 0);
160	156k	}
161
162	345	while (max && *--rp == 0)
163	0	max--;
164
165	345	r->top = max;
166	345	r->neg = 0;
167	345	bn_pollute(r);
168
169	345	return 1;
170	345	}
171

Coverage Report

Created: 2023-06-08 06:41