Mercurial > dropbear

comparison pkcs_1_oaep_encode.c @ 143:5d99163f7e32 libtomcrypt-orig

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
import of libtomcrypt 0.99
author Matt Johnston <matt@ucc.asn.au>
date Sun, 19 Dec 2004 11:34:45 +0000
parents 6362d3854bb4
children
comparison
equal deleted inserted replaced
15:6362d3854bb4 143:5d99163f7e32
18 const unsigned char *lparam, unsigned long lparamlen, 18 const unsigned char *lparam, unsigned long lparamlen,
19 unsigned long modulus_bitlen, prng_state *prng, 19 unsigned long modulus_bitlen, prng_state *prng,
20 int prng_idx, int hash_idx, 20 int prng_idx, int hash_idx,
21 unsigned char *out, unsigned long *outlen) 21 unsigned char *out, unsigned long *outlen)
22 { 22 {
23 unsigned char DB[1024], seed[MAXBLOCKSIZE], mask[sizeof(DB)]; 23 unsigned char *DB, *seed, *mask;
24 unsigned long hLen, x, y, modulus_len; 24 unsigned long hLen, x, y, modulus_len;
25 int err; 25 int err;
26 26
27 _ARGCHK(msg != NULL); 27 _ARGCHK(msg != NULL);
28 _ARGCHK(out != NULL); 28 _ARGCHK(out != NULL);
39 } 39 }
40 40
41 hLen = hash_descriptor[hash_idx].hashsize; 41 hLen = hash_descriptor[hash_idx].hashsize;
42 modulus_len = (modulus_bitlen >> 3) + (modulus_bitlen & 7 ? 1 : 0); 42 modulus_len = (modulus_bitlen >> 3) + (modulus_bitlen & 7 ? 1 : 0);
43 43
44 /* allocate ram for DB/mask/salt of size modulus_len */
45 DB = XMALLOC(modulus_len);
46 mask = XMALLOC(modulus_len);
47 seed = XMALLOC(modulus_len);
48 if (DB == NULL || mask == NULL || seed == NULL) {
49 if (DB != NULL) {
50 XFREE(DB);
51 }
52 if (mask != NULL) {
53 XFREE(mask);
54 }
55 if (seed != NULL) {
56 XFREE(seed);
57 }
58 return CRYPT_MEM;
59 }
60
44 /* test message size */ 61 /* test message size */
45 if (modulus_len >= sizeof(DB) || msglen > (modulus_len - 2*hLen - 2)) { 62 if (msglen > (modulus_len - 2*hLen - 2)) {
46 return CRYPT_PK_INVALID_SIZE; 63 err = CRYPT_PK_INVALID_SIZE;
64 goto __ERR;
47 } 65 }
48 66
49 /* get lhash */ 67 /* get lhash */
50 // DB == lhash || PS || 0x01 || M, PS == k - mlen - 2hlen - 2 zeroes 68 /* DB == lhash || PS || 0x01 || M, PS == k - mlen - 2hlen - 2 zeroes */
51 x = sizeof(DB); 69 x = modulus_len;
52 if (lparam != NULL) { 70 if (lparam != NULL) {
53 if ((err = hash_memory(hash_idx, lparam, lparamlen, DB, &x)) != CRYPT_OK) { 71 if ((err = hash_memory(hash_idx, lparam, lparamlen, DB, &x)) != CRYPT_OK) {
54 return err; 72 goto __ERR;
55 } 73 }
56 } else { 74 } else {
57 /* can't pass hash_memory a NULL so use DB with zero length */ 75 /* can't pass hash_memory a NULL so use DB with zero length */
58 if ((err = hash_memory(hash_idx, DB, 0, DB, &x)) != CRYPT_OK) { 76 if ((err = hash_memory(hash_idx, DB, 0, DB, &x)) != CRYPT_OK) {
59 return err; 77 goto __ERR;
60 } 78 }
61 } 79 }
62 80
63 /* append PS then 0x01 (to lhash) */ 81 /* append PS then 0x01 (to lhash) */
64 x = hLen; 82 x = hLen;
74 DB[x++] = *msg++; 92 DB[x++] = *msg++;
75 } 93 }
76 94
77 /* now choose a random seed */ 95 /* now choose a random seed */
78 if (prng_descriptor[prng_idx].read(seed, hLen, prng) != hLen) { 96 if (prng_descriptor[prng_idx].read(seed, hLen, prng) != hLen) {
79 return CRYPT_ERROR_READPRNG; 97 err = CRYPT_ERROR_READPRNG;
98 goto __ERR;
80 } 99 }
81 100
82 /* compute MGF1 of seed (k - hlen - 1) */ 101 /* compute MGF1 of seed (k - hlen - 1) */
83 if ((err = pkcs_1_mgf1(seed, hLen, hash_idx, mask, modulus_len - hLen - 1)) != CRYPT_OK) { 102 if ((err = pkcs_1_mgf1(seed, hLen, hash_idx, mask, modulus_len - hLen - 1)) != CRYPT_OK) {
84 return err; 103 goto __ERR;
85 } 104 }
86 105
87 /* xor against DB */ 106 /* xor against DB */
88 for (y = 0; y < (modulus_len - hLen - 1); y++) { 107 for (y = 0; y < (modulus_len - hLen - 1); y++) {
89 DB[y] ^= mask[y]; 108 DB[y] ^= mask[y];
90 } 109 }
91 110
92 /* compute MGF1 of maskedDB (hLen) */ 111 /* compute MGF1 of maskedDB (hLen) */
93 if ((err = pkcs_1_mgf1(DB, modulus_len - hLen - 1, hash_idx, mask, hLen)) != CRYPT_OK) { 112 if ((err = pkcs_1_mgf1(DB, modulus_len - hLen - 1, hash_idx, mask, hLen)) != CRYPT_OK) {
94 return err; 113 goto __ERR;
95 } 114 }
96 115
97 /* XOR against seed */ 116 /* XOR against seed */
98 for (y = 0; y < hLen; y++) { 117 for (y = 0; y < hLen; y++) {
99 seed[y] ^= mask[y]; 118 seed[y] ^= mask[y];
100 } 119 }
101 120
102 /* create string of length modulus_len */ 121 /* create string of length modulus_len */
103 if (*outlen < modulus_len) { 122 if (*outlen < modulus_len) {
104 return CRYPT_BUFFER_OVERFLOW; 123 err = CRYPT_BUFFER_OVERFLOW;
124 goto __ERR;
105 } 125 }
106 126
107 /* start output which is 0x00 || maskedSeed || maskedDB */ 127 /* start output which is 0x00 || maskedSeed || maskedDB */
108 x = 0; 128 x = 0;
109 out[x++] = 0x00; 129 out[x++] = 0x00;
112 } 132 }
113 for (y = 0; y < modulus_len - hLen - 1; y++) { 133 for (y = 0; y < modulus_len - hLen - 1; y++) {
114 out[x++] = DB[y]; 134 out[x++] = DB[y];
115 } 135 }
116 *outlen = x; 136 *outlen = x;
117 137
138 err = CRYPT_OK;
139 __ERR:
118 #ifdef CLEAN_STACK 140 #ifdef CLEAN_STACK
119 zeromem(DB, sizeof(DB)); 141 zeromem(DB, modulus_len);
120 zeromem(seed, sizeof(seed)); 142 zeromem(seed, modulus_len);
121 zeromem(mask, sizeof(mask)); 143 zeromem(mask, modulus_len);
122 #endif 144 #endif
123 145
124 return CRYPT_OK; 146 XFREE(seed);
147 XFREE(mask);
148 XFREE(DB);
149
150 return err;
125 } 151 }
126 152
127 #endif /* PKCS_1 */ 153 #endif /* PKCS_1 */
128 154