void g_PackID(void* binary_id, size_t binary_id_len, string& packed_id)
{
s_Scramble((unsigned char*) binary_id, binary_id_len);
size_t packed_id_len;
base64url_encode(NULL, binary_id_len, NULL, 0, &packed_id_len);
packed_id.resize(packed_id_len);
packed_id[0] = '\0';
base64url_encode(binary_id, binary_id_len,
const_cast<char*>(packed_id.data()), packed_id_len, NULL);
}
int write_image (struct lev_storage_file *E, char *data, crc32_logpos_t *P) {
clearin ();
assert (E->type == LEV_STORAGE_FILE || (E->type == LEV_STORAGE_HIDE_FILE && !E->size));
const unsigned zero = 0;
int l = (E->size + 3) & -4;
int padded_zero_bytes = l - E->size;
assert (padded_zero_bytes >= 0 && padded_zero_bytes < 4);
if (padded_zero_bytes) {
assert (!memcmp (data + E->size, &zero, padded_zero_bytes));
}
P->crc32_complement = crc32_partial (E, sizeof (*E), P->crc32_complement);
P->log_pos += sizeof (*E);
P->crc32_complement = crc32_partial (data, l, P->crc32_complement);
P->log_pos += l;
struct lev_crc32 C;
C.type = LEV_CRC32;
C.pos = P->log_pos;
C.crc32 = ~P->crc32_complement;
C.timestamp = last_mtime;
P->crc32_complement = crc32_partial (&C, sizeof (C), P->crc32_complement);
P->log_pos += sizeof (C);
if (writeout (E, sizeof (*E)) < 0 ||
writeout (data, l) < 0 ||
writeout (&C, sizeof (C)) < 0 ||
flushout () < 0) {
return -1;
}
if (test_mode) {
char base64url_secret[12];
int r = base64url_encode ((unsigned char *) &E->secret, 8, base64url_secret, 12);
assert (!r);
printf ("wget -O %d.jpg http://127.0.0.1:%d/v%lld/%x/%s.jpg\n", E->local_id, http_port, volume_id, E->local_id, base64url_secret);
}
return 0;
}
static int create_tag (scs_t *ctx, scs_keyset_t *ks, int skip_encoding)
{
size_t i;
scs_atoms_t *ats = &ctx->atoms;
enum { NUM_ATOMS = 4 };
struct {
const char *id;
uint8_t *raw;
char *enc;
size_t raw_sz, enc_sz;
} A[NUM_ATOMS] = {
{
"SCS DATA",
ats->data,
ats->b64_data,
ats->data_sz,
BASE64_LENGTH(ats->data_sz)
},
{
"SCS TSTAMP",
(uint8_t *) ats->tstamp,
ats->b64_tstamp,
strlen(ats->tstamp),
sizeof(ats->b64_tstamp)
},
{
"SCS TID",
(uint8_t *) ks->tid,
ats->b64_tid,
strlen(ks->tid),
sizeof(ats->b64_tid)
},
{
"SCS IV",
ats->iv,
ats->b64_iv,
ks->block_sz,
BASE64_LENGTH(ks->block_sz)
}
};
/* If requested, create Base-64 encoded versions of atoms. */
if (!skip_encoding)
{
for (i = 0; i < NUM_ATOMS; ++i)
{
if (base64url_encode(A[i].raw, A[i].raw_sz,
A[i].enc, &A[i].enc_sz))
{
scs_set_error(ctx, SCS_ERR_ENCODE, "%s encode failed", A[i].id);
return -1;
}
}
}
/* Create auth tag. */
if (D.tag(ctx, ks))
return -1;
size_t b64_tag = sizeof ats->b64_tag;
/* Base-64 encode the auth tag. */
if (base64url_encode(ats->tag, ats->tag_sz, ats->b64_tag, &b64_tag))
{
scs_set_error(ctx, SCS_ERR_ENCODE, "tag encode failed");
return -1;
}
return 0;
}
int main (int argc, char **argv)
{
const char *evector[7] = {
"",
"f",
"fo",
"foo",
"foob",
"fooba",
"foobar"};
const char *dvector[7] = {
"",
"Zg",
"Zm8",
"Zm9v",
"Zm9vYg",
"Zm9vYmE",
"Zm9vYmFy"};
char dest[64] = {'\0'};
size_t dlen = 0;
int r, i;
for (i = 0; i < 7; i++) {
memset(dest, 0, 64);
r = base64url_encode(dest, 63, evector[i], strlen(evector[i]), &dlen);
if (r < 0) {
printf("FAIL encode \"%s\"\n", evector[i]);
continue;
}
if (strlen(dvector[i]) != dlen) {
printf("FAIL encode \"%s\"\n", evector[i]);
continue;
}
if (strncmp(dvector[i], dest, dlen)) {
printf("FAIL encode \"%s\"\n", evector[i]);
continue;
}
printf("PASS encode \"%s\" => \"%s\"\n", evector[i], dest);
}
for (i = 0; i < 7; i++) {
memset(dest, 0, 64);
r = base64url_decode(dest, 63, dvector[i], strlen(dvector[i]), &dlen);
if (r < 0) {
printf("FAIL decode \"%s\" r=%d\n", dvector[i], r);
continue;
}
if (strlen(evector[i]) != dlen) {
printf("FAIL decode \"%s\" => \"%s\"(%zu)\n", dvector[i], dest, dlen);
continue;
}
if (strncmp(evector[i], dest, dlen)) {
printf("FAIL decode \"%s\" =>\"%s\"\n", dvector[i], dest);
continue;
}
printf("PASS decode \"%s\" => \"%s\"\n", dvector[i], dest);
}
return 0;
}
