/*void RSAPublicKeyFree(RSAPublicKey* key) {
if (key) {
if (key->n)
free(key->n);
if (key->rr)
free(key->rr);
free(key);
}
}
*/
RSAPublicKey RSAPublicKeyFromBuf(const uint8_t* buf, uint64_t len) {
// RSAPublicKey* key = RSAPublicKeyNew();
RSAPublicKey key;
MemcpyState st;
uint64_t key_len;
StatefulInit(&st, (void*)buf, len);
StatefulMemcpy(&st, &key.len, sizeof(key.len));
key_len = key.len * sizeof(uint32_t); /* key length in bytes. */
/* Sanity Check the key length. */
/* if (RSA1024NUMBYTES != key_len &&
RSA2048NUMBYTES != key_len &&
RSA4096NUMBYTES != key_len &&
RSA8192NUMBYTES != key_len) {
// RSAPublicKeyFree(key);
// return NULL;
}
*/
// key->n = (uint32_t*) malloc(key_len);
// key->rr = (uint32_t*) malloc(key_len);
StatefulMemcpy(&st, &key.n0inv, sizeof(key.n0inv));
StatefulMemcpy(&st, key.n, key_len);
StatefulMemcpy(&st, key.rr, key_len);
// if (st.overrun || st.remaining_len != 0) { /* Underrun or overrun. */
// RSAPublicKeyFree(key);
// return NULL;
// }
return key;
}
RSAPublicKey* RSAPublicKeyFromBuf(const uint8_t* buf, int len) {
RSAPublicKey* key = (RSAPublicKey*) Malloc(sizeof(RSAPublicKey));
MemcpyState st;
int key_len;
st.remaining_buf = (uint8_t*) buf;
st.remaining_len = len;
StatefulMemcpy(&st, &key->len, sizeof(key->len));
key_len = key->len * sizeof(uint32_t); /* key length in bytes. */
key->n = (uint32_t*) Malloc(key_len);
key->rr = (uint32_t*) Malloc(key_len);
StatefulMemcpy(&st, &key->n0inv, sizeof(key->n0inv));
StatefulMemcpy(&st, key->n, key_len);
StatefulMemcpy(&st, key->rr, key_len);
if (st.remaining_len != 0) { /* Underrun or overrun. */
Free(key->n);
Free(key->rr);
Free(key);
return NULL;
}
return key;
}
/* Test StatefulMemcpy */
static void StatefulMemcpyTest(void) {
MemcpyState s;
char buf[129];
char want[129];
char* src1 = "ThisIsATest";
char* src2 = "ThisIsOnlyATest";
memset(want, 0, sizeof(want));
memset(buf, 0, sizeof(buf));
/* Small copies */
StatefulInit(&s, src1, 12);
TEST_PTR_EQ(buf, StatefulMemcpy(&s, buf, 6), "StatefulMemcpy(6) retval");
TEST_EQ(6, s.remaining_len, "StatefulMemcpy(6) len");
TEST_PTR_EQ(src1 + 6, s.remaining_buf, "StatefulMemcpy(6) buf");
/* Using strcmp() is a convenient way to check that we didn't
* overwrite the 0-byte following what we expected to copy. */
TEST_EQ(0, strcmp("ThisIs", buf), "StatefulMemcpy(6) contents");
TEST_EQ(0, s.overrun, "StatefulMemcpy(6) overrun");
TEST_PTR_EQ(buf, StatefulMemcpy(&s, buf, 5), "StatefulMemcpy(5) retval");
/* Note that we shouldn't have copied the last byte out of the
* stateful buffer, so we don't overwrite the last character of the
* string that was in buf. */
TEST_EQ(0, strcmp("ATests", buf), "StatefulMemcpy(5) contents");
/* Use entire buffer */
memset(buf, 1, sizeof(buf));
StatefulInit(&s, src2, 16);
TEST_PTR_EQ(buf, StatefulMemcpy(&s, buf, 16), "StatefulMemcpy(all) retval");
TEST_EQ(0, s.remaining_len, "StatefulMemcpy(all) len");
TEST_PTR_EQ(src2 + 16, s.remaining_buf, "StatefulMemcpy(all) buf");
TEST_EQ(0, s.overrun, "StatefulMemcpy(all) overrun");
TEST_EQ(0, strcmp(src2, buf), "StatefulMemcpy(all) contents");
/* Zero-length copy is ok (but meaningless) */
TEST_PTR_EQ(buf, StatefulMemcpy(&s, buf, 0),
"StatefulMemcpy(0) retval");
TEST_EQ(0, s.remaining_len, "StatefulMemcpy(0) len");
TEST_PTR_EQ(src2 + 16, s.remaining_buf, "StatefulMemcpy(0) buf");
TEST_EQ(0, s.overrun, "StatefulMemcpy(0) overrun");
TEST_EQ(0, strcmp(src2, buf), "StatefulMemcpy(0) contents");
/* Can't use even one byte past that */
TEST_PTR_EQ(NULL, StatefulMemcpy(&s, buf, 1),
"StatefulMemcpy(+1) retval");
TEST_EQ(0, s.remaining_len, "StatefulMemcpy(+1) len");
TEST_EQ(1, s.overrun, "StatefulMemcpy(+1) overrun");
TEST_EQ(0, strcmp(src2, buf), "StatefulMemcpy(+1) contents");
/* Overrun */
memset(buf, 0, sizeof(buf));
StatefulInit(&s, "Small", 5);
TEST_PTR_EQ(NULL, StatefulMemcpy(&s, buf, 9), "StatefulMemcpy(9) retval");
TEST_EQ(1, s.overrun, "StatefulMemcpy(9) overrun");
/* Once overrun, always overrun, even if we now ask for a small skip */
TEST_PTR_EQ(NULL, StatefulMemcpy(&s, buf, 4),
"StatefulMemcpy(9+1) retval");
TEST_EQ(1, s.overrun, "StatefulMemcpy(9+1) overrun");
TEST_EQ(0, memcmp(want, buf, sizeof(want)), "StatefulMemcpy(+1) contents");
/* Overrun with potential wraparound */
StatefulInit(&s, "Larger", 6);
TEST_PTR_EQ(NULL, StatefulMemcpy(&s, buf, -1), "StatefulMemcpy(-1) retval");
TEST_EQ(1, s.overrun, "StatefulMemcpy(-1) overrun");
TEST_EQ(0, memcmp(want, buf, sizeof(want)), "StatefulMemcpy(+1) contents");
}
