/**
* @brief Return fully qualified representation for a key.
*
* Return a fully qualified representation for a key, including
* the intial key type BIT@ (internal chunks), CHK@ (content
* hash key) or SSK@ (public and private keys).
* Unknown key types are prepended by the four digit hex value
* of the type.
*
* @param key pointer to a key
*
* @result pointer to a string containing the fully qualified base64 key
*/
const char *key_long(const chkey_t *key)
{
#undef BUFNUM
#undef BUFSIZE
#define BUFNUM 16
#define BUFSIZE (8+KEY1SIZE+1+KEY2SIZE+1)
static char *buff[BUFNUM] = {
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL
};
static int which = 0;
uint8_t key1[SHA1SIZE+1+2];
uint8_t key2[EK5SIZE];
which = (which + 1) % BUFNUM;
xfree(buff[which]);
buff[which] = (char *)xcalloc(BUFSIZE, sizeof(char));
memcpy(key1, key->sha1.digest, SHA1SIZE);
key1[SHA1SIZE] = key->log2size;
key1[SHA1SIZE+1] = key->type[0];
key1[SHA1SIZE+2] = key->type[1];
memcpy(key2, key->ek5.digest, EK5SIZE);
if (key->type[0] == MSB(K_CHK) && key->type[1] == LSB(K_CHK)) {
pm_snprintf(buff[which], BUFSIZE,
"CHK@%s,%s",
base64_encode(key1, SHA1SIZE+1+2),
base64_encode(key2, EK5SIZE));
} else if (key->type[0] == MSB(K_BIT) && key->type[1] == LSB(K_BIT)) {
pm_snprintf(buff[which], BUFSIZE,
"BIT@%s,%s",
base64_encode(key1, SHA1SIZE+1+2),
base64_encode(key2, EK5SIZE));
} else if (key->type[0] == MSB(K_SSK_P) && key->type[1] == LSB(K_SSK_P)) {
pm_snprintf(buff[which], BUFSIZE,
"SSK@%s",
base64_encode(key1, SHA1SIZE+1+2));
} else if (key->type[0] == MSB(K_SSK_S) && key->type[1] == LSB(K_SSK_S)) {
pm_snprintf(buff[which], BUFSIZE,
"SSK@%s",
base64_encode(key1, SHA1SIZE));
} else {
pm_snprintf(buff[which], BUFSIZE,
"0x%02x%02x@%s,%s",
key->type[0], key->type[1],
base64_encode(key1, SHA1SIZE+1+2),
base64_encode(key2, EK5SIZE));
}
return buff[which];
}
static void
writeLabel(pixel ** const pixels,
int const pixcols,
int const pixrows,
pixval const maxval,
const struct colorSystem * const cs) {
pixel rgbcolor; /* color of text */
char sysdesc[256];
PPM_ASSIGN(rgbcolor, maxval, maxval, maxval);
pm_snprintf(sysdesc, sizeof(sysdesc),
"System: %s\n"
"Primary illuminants (X, Y)\n"
" Red: %0.4f, %0.4f\n"
" Green: %0.4f, %0.4f\n"
" Blue: %0.4f, %0.4f\n"
"White point (X, Y): %0.4f, %0.4f",
cs->name, cs->xRed, cs->yRed, cs->xGreen, cs->yGreen,
cs->xBlue, cs->yBlue, cs->xWhite, cs->yWhite);
sysdesc[sizeof(sysdesc)-1] = '\0'; /* for robustness */
ppmd_text(pixels, pixcols, pixrows, maxval,
pixcols / 3, Sz(24), Sz(12), 0, sysdesc,
PPMD_NULLDRAWPROC, (char *) &rgbcolor);
}
/**
* @brief Return shortened representation for a key.
*
* Return a short string representation for a key for debugging,
* printing and hiding full keys from logs.
*
* @param key pointer to a key
*
* @result pointer to a string containing the shortened key
*/
const char *key_short(const chkey_t *key)
{
#undef BUFNUM
#undef BUFSIZE
#define BUFNUM 16
#define BUFSIZE (8+8+3+1)
static char *buff[BUFNUM] = {
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL
};
static int which = 0;
which = (which + 1) % BUFNUM;
xfree(buff[which]);
buff[which] = (char *)xcalloc(BUFSIZE, sizeof(char));
switch ((key->type[0] << 8) + key->type[1]) {
case K_CHK:
pm_snprintf(buff[which], BUFSIZE,
"CHK@%-8.8s...",
base64_encode(key->sha1.digest, 7));
break;
case K_KSK:
pm_snprintf(buff[which], BUFSIZE,
"KSK@%-8.8s...",
base64_encode(key->sha1.digest, 7));
break;
case K_SSK_P:
case K_SSK_S:
pm_snprintf(buff[which], BUFSIZE,
"SSK@%-8.8s...",
base64_encode(key->sha1.digest, 7));
break;
case K_BIT:
pm_snprintf(buff[which], BUFSIZE,
"BIT@%-8.8s...",
base64_encode(key->sha1.digest, 7));
break;
default:
pm_snprintf(buff[which], BUFSIZE,
"0x%02x%02x@%-8.8s...",
key->type[0], key->type[1],
base64_encode(key->sha1.digest, 7));
}
return buff[which];
}
/**
* @brief Return base64 string for a key
*
* Return a string representation for a key.
* The bytes are base64 encoded.
*
* @param key pointer to a key
*
* @result pointer to a string containing the base64 encoded key
*/
const char *key_str(const chkey_t *key)
{
#undef BUFNUM
#undef BUFSIZE
#define BUFNUM 16
#define BUFSIZE (KEY1SIZE+1+KEY2SIZE+1)
static char *buff[BUFNUM] = {
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL
};
static int which = 0;
uint8_t key1[SHA1SIZE+1+2];
uint8_t key2[EK5SIZE];
which = (which + 1) % BUFNUM;
xfree(buff[which]);
buff[which] = (char *)xcalloc(BUFSIZE, sizeof(char));
memcpy(&key1[0], &key->sha1, SHA1SIZE);
memcpy(&key1[SHA1SIZE], &key->log2size, 1);
memcpy(&key1[SHA1SIZE+1], &key->type, 2);
memcpy(&key2[0], &key->ek5, EK5SIZE);
if (key->type[0] == MSB(K_CHK) && key->type[1] == LSB(K_CHK)) {
pm_snprintf(buff[which], BUFSIZE, "%s,%s",
base64_encode(key1, SHA1SIZE+1+2),
base64_encode(key2, EK5SIZE));
} else if (key->type[0] == MSB(K_BIT) && key->type[1] == LSB(K_BIT)) {
pm_snprintf(buff[which], BUFSIZE, "%s,%s",
base64_encode(key1, SHA1SIZE+1+2),
base64_encode(key2, EK5SIZE));
} else if (key->type[0] == MSB(K_SSK_P) && key->type[1] == LSB(K_SSK_P)) {
pm_snprintf(buff[which], BUFSIZE, "%s",
base64_encode(key1, SHA1SIZE+1+2));
} else if (key->type[0] == MSB(K_SSK_S) && key->type[1] == LSB(K_SSK_S)) {
pm_snprintf(buff[which], BUFSIZE, "%s",
base64_encode(key1, SHA1SIZE));
} else {
pm_snprintf(buff[which], BUFSIZE, "%s",
base64_encode(key1, SHA1SIZE+1+2));
}
return buff[which];
}
static char *at_file_line(char *file, uint32_t line)
{
static char buff[4][80];
static int which = 0;
which = (which + 1) % 4;
if (NULL == file) {
buff[which][0] = '\0';
} else {
pm_snprintf(buff[which], sizeof(buff[which]), " at %s:%d", file, line);
}
return buff[which];
}
/**
* @brief Create the public SSK for a private SSK
*
* Create a public key from a private key,
* simply by hashing the hex string of the SHA1 digest.
*
* @param key pointer to a key to receive the public SSK
* @param ssk pointer to a key containing a private SSK
*
* @result zero on success
*/
int key_ssk_pub_from_priv(chkey_t *key, const chkey_t *ssk)
{
char hex[SHA1SIZE*2+1];
sha1_state_t sha1;
size_t size;
FUN("key_ssk_pub_from_priv");
size = pm_snprintf(hex, sizeof(hex), "%s",
sha1_hexstr(&ssk->sha1));
sha1_init(&sha1);
sha1_append(&sha1, hex, size);
sha1_finish(&sha1, &key->sha1);
key->type[0] = MSB(K_SSK_P);
key->type[1] = LSB(K_SSK_P);
key->log2size = log2size(size);
memset(&key->ek5, 0, sizeof(key->ek5));
return 0;
}
static const char *at_file_line(const char *file, unsigned line)
{
static char buff[128];
pm_snprintf(buff, sizeof(buff), " at %s.%u", file, line);
return buff;
}
