1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#ifndef _BIGNUM_H
#define _BIGNUM_H
#pragma ident "%Z%%M% %I% %E% SMI"
#ifdef __cplusplus
extern "C" {
#endif
#include <sys/types.h>
typedef int BIG_ERR_CODE;
#define BITSINBYTE 8
#ifdef BIGNUM_CHUNK_32
#define BIG_CHUNK_SIZE 32
#define BIG_CHUNK_TYPE uint32_t
#define BIG_CHUNK_HIGHBIT 0x80000000
#define BIG_CHUNK_ALLBITS 0xffffffff
#define BIG_CHUNK_LOWHALFBITS 0xffff
#define BIG_CHUNK_HALF_HIGHBIT 0x8000
#else
#define BIG_CHUNK_SIZE 64
#define BIG_CHUNK_TYPE uint64_t
#define BIG_CHUNK_HIGHBIT 0x8000000000000000ULL
#define BIG_CHUNK_ALLBITS 0xffffffffffffffffULL
#define BIG_CHUNK_LOWHALFBITS 0xffffffffULL
#define BIG_CHUNK_HALF_HIGHBIT 0x80000000ULL
#endif
#define CHARLEN2BIGNUMLEN(x) ((x + sizeof (BIG_CHUNK_TYPE) - 1) / \
sizeof (BIG_CHUNK_TYPE))
#define BIGNUM_WORDSIZE (BIG_CHUNK_SIZE / BITSINBYTE) /* word size in bytes */
#define BIG_CHUNKS_FOR_160BITS ((160 + BIG_CHUNK_SIZE - 1) / BIG_CHUNK_SIZE)
/*
* leading 0's are permitted
* 0 should be represented by size>=1, size>=len>=1, sign=1,
* value[i]=0 for 0<i<len
*/
typedef struct {
int size; /* the size of memory allocated for value (in words) */
int len; /* the number of words that hold valid data in value */
int sign; /* 1 for nonnegative, -1 for negative */
int malloced; /* 1 if value was malloced 0 if not */
BIG_CHUNK_TYPE *value;
} BIGNUM;
typedef struct {
int64_t size; /* key size in bits */
BIGNUM p; /* p */
BIGNUM q; /* q */
BIGNUM n; /* n = p * q (the modulus) */
BIGNUM d; /* private exponent */
BIGNUM e; /* public exponent */
BIGNUM dmodpminus1; /* d mod (p - 1) */
BIGNUM dmodqminus1; /* d mod (q - 1) */
BIGNUM pinvmodq; /* p^(-1) mod q */
BIGNUM p_rr; /* 2^(2*(32*p->len)) mod p */
BIGNUM q_rr; /* 2^(2*(32*q->len)) mod q */
BIGNUM n_rr; /* 2^(2*(32*n->len)) mod n */
} RSAkey;
typedef struct {
int64_t size; /* key size in bits */
BIGNUM q; /* q (160-bit prime) */
BIGNUM p; /* p (<size-bit> prime) */
BIGNUM g; /* g (the base) */
BIGNUM x; /* private key (< q) */
BIGNUM y; /* = g^x mod p */
BIGNUM k; /* k (random number < q) */
BIGNUM r; /* r (signiture 1st part) */
BIGNUM s; /* s (signiture 1st part) */
BIGNUM v; /* v (verification value - should be = r ) */
BIGNUM p_rr; /* 2^(2*(32*p->len)) mod p */
BIGNUM q_rr; /* 2^(2*(32*q->len)) mod q */
} DSAkey;
#define BIGTMPSIZE 65
#define BIG_TRUE 1
#define BIG_FALSE 0
/* error codes */
#define BIG_OK 0
#define BIG_NO_MEM -1
#define BIG_INVALID_ARGS -2
#define BIG_DIV_BY_0 -3
#define BIG_NO_RANDOM -4
#define BIG_TEST_FAILED -5
#define arraysize(x) (sizeof (x) / sizeof (x[0]))
#ifdef MODEXP_FLOAT
void conv_d16_to_i32(uint32_t *i32, double *d16, int64_t *tmp, int ilen);
void conv_i32_to_d32(double *d32, uint32_t *i32, int len);
void conv_i32_to_d16(double *d16, uint32_t *i32, int len);
void conv_i32_to_d32_and_d16(double *d32, double *d16,
uint32_t *i32, int len);
void mont_mulf_noconv(uint32_t *result, double *dm1, double *dm2, double *dt,
double *dn, uint32_t *nint, int nlen, double dn0);
#endif
BIG_ERR_CODE ncp_big_init(BIGNUM *number, int size);
BIG_ERR_CODE ncp_big_extend(BIGNUM *number, int size);
void ncp_big_finish(BIGNUM *number);
int ncp_big_is_zero(BIGNUM *n);
void ncp_kcl2bignum(BIGNUM *bn, uchar_t *kn, size_t len);
void ncp_bignum2kcl(uchar_t *kn, BIGNUM *bn, size_t len);
BIG_ERR_CODE ncp_DSA_key_init(DSAkey *key, int size);
void ncp_DSA_key_finish(DSAkey *key);
BIG_ERR_CODE ncp_RSA_key_init(RSAkey *key, int psize, int qsize);
void ncp_RSA_key_finish(RSAkey *key);
BIG_ERR_CODE ncp_big_mont_rr(BIGNUM *result, BIGNUM *n);
BIG_ERR_CODE ncp_big_modexp(BIGNUM *result, BIGNUM *a, BIGNUM *e,
BIGNUM *n, BIGNUM *n_rr, void *ncp, void *reqp);
BIG_ERR_CODE ncp_big_modexp_crt(BIGNUM *result, BIGNUM *a, BIGNUM *dmodpminus1,
BIGNUM *dmodqminus1, BIGNUM *p, BIGNUM *q, BIGNUM *pinvmodq,
BIGNUM *p_rr, BIGNUM *q_rr, void *ncp, void *reqp);
int ncp_big_cmp_abs(BIGNUM *a, BIGNUM *b);
BIG_ERR_CODE ncp_randombignum(BIGNUM *r, int lengthinbits);
BIG_ERR_CODE ncp_big_div_pos(BIGNUM *result, BIGNUM *remainder,
BIGNUM *aa, BIGNUM *bb);
BIG_ERR_CODE ncp_big_ext_gcd_pos(BIGNUM *gcd, BIGNUM *cm, BIGNUM *ce,
BIGNUM *m, BIGNUM *e);
BIG_ERR_CODE ncp_big_add(BIGNUM *result, BIGNUM *aa, BIGNUM *bb);
BIG_ERR_CODE ncp_big_mul(BIGNUM *result, BIGNUM *aa, BIGNUM *bb);
BIG_ERR_CODE ncp_big_nextprime_pos(BIGNUM *result, BIGNUM *n, void *ncp,
void *reqp);
BIG_ERR_CODE ncp_big_sub_pos(BIGNUM *result, BIGNUM *aa, BIGNUM *bb);
BIG_ERR_CODE ncp_big_copy(BIGNUM *dest, BIGNUM *src);
BIG_ERR_CODE ncp_big_sub(BIGNUM *result, BIGNUM *aa, BIGNUM *bb);
int ncp_big_bitlength(BIGNUM *n);
#ifdef __cplusplus
}
#endif
#endif /* _BIGNUM_H */
|
