static cdk_error_t
write_mpibuf (cdk_stream_t out, bigint_t mpi[MAX_CDK_PK_PARTS], size_t count)
{
size_t i;
cdk_error_t rc;
for (i = 0; i < count; i++)
{
rc = write_mpi (out, mpi[i]);
if (rc)
return rc;
}
return 0;
}
/*-------------------------------------------------------------------------*/
int FTI_WriteMpiVar(int varID, FTIT_configuration* FTI_Conf, FTIT_execution* FTI_Exec,
FTIT_topology* FTI_Topo, FTIT_checkpoint* FTI_Ckpt,
FTIT_dataset* FTI_Data)
{
char str[FTI_BUFS];
WriteMPIInfo_t write_info;
int res;
memcpy( &write_info.pfh, FTI_Exec->iCPInfo.fh, sizeof(FTI_MI_FH) );
write_info.offset = FTI_Exec->iCPInfo.offset;
write_info.FTI_Conf = FTI_Conf;
int i;
for (i = 0; i < FTI_Exec->nbVar; i++) {
if ( FTI_Data[i].id == varID ) {
if ( !(FTI_Data[i].isDevicePtr) ){
FTI_Print(str,FTI_INFO);
if (( res = write_mpi(FTI_Data[i].ptr, FTI_Data[i].size, &write_info), "Storing Data to checkpoint file")!=FTI_SCES){
snprintf(str, FTI_BUFS, "Dataset #%d could not be written.", FTI_Data[i].id);
FTI_Print(str, FTI_EROR);
MPI_File_close(&write_info.pfh);
return res;
}
}
#ifdef GPUSUPPORT
// dowload data from the GPU if necessary
// Data are stored in the GPU side.
else {
snprintf(str, FTI_BUFS, "Dataset #%d Writing GPU Data.", FTI_Data[i].id);
FTI_Print(str,FTI_INFO);
if ((res = FTI_Try(
FTI_TransferDeviceMemToFileAsync(&FTI_Data[i], write_mpi, &write_info),
"moving data from GPU to storage")) != FTI_SCES) {
snprintf(str, FTI_BUFS, "Dataset #%d could not be written.", FTI_Data[i].id);
FTI_Print(str, FTI_EROR);
MPI_File_close(&write_info.pfh);
return res;
}
}
#endif
}
write_info.offset += FTI_Data[i].size;
}
FTI_Exec->iCPInfo.result = FTI_SCES;
return FTI_SCES;
}
void io_com_dump(MPI_Comm comm, const Coords *coords, const char *name, long id, int n, const int *ii, const float3 *rr) {
char fname[FILENAME_MAX] = {0}, *data;
long nchar = 0;
EMALLOC(MAX_CHAR_PER_LINE * n, &data);
if (m::is_master(comm))
UC(os_mkdir(BASE));
gen_fname(name, id, fname);
UC(nchar = swrite(coords, n, ii, rr, /**/ data));
write_mpi(comm, fname, nchar, data);
EFREE(data);
}
/* Create an OTR Data message. Pass the plaintext as msg, and an
* optional chain of TLVs. A newly-allocated string will be returned in
* *encmessagep. */
gcry_error_t otrl_proto_create_data(char **encmessagep, ConnContext *context,
const char *msg, const OtrlTLV *tlvs, unsigned char flags)
{
size_t justmsglen = strlen(msg);
size_t msglen = justmsglen + 1 + otrl_tlv_seriallen(tlvs);
size_t buflen;
size_t pubkeylen;
unsigned char *buf = NULL;
unsigned char *bufp;
size_t lenp;
DH_sesskeys *sess = &(context->sesskeys[1][0]);
gcry_error_t err;
size_t reveallen = 20 * context->numsavedkeys;
size_t base64len;
char *base64buf = NULL;
unsigned char *msgbuf = NULL;
enum gcry_mpi_format format = GCRYMPI_FMT_USG;
char *msgdup;
int version = context->protocol_version;
/* Make sure we're actually supposed to be able to encrypt */
if (context->msgstate != OTRL_MSGSTATE_ENCRYPTED ||
context->their_keyid == 0) {
return gcry_error(GPG_ERR_CONFLICT);
}
/* We need to copy the incoming msg, since it might be an alias for
* context->lastmessage, which we'll be freeing soon. */
msgdup = gcry_malloc_secure(justmsglen + 1);
if (msgdup == NULL) {
return gcry_error(GPG_ERR_ENOMEM);
}
strcpy(msgdup, msg);
*encmessagep = NULL;
/* Header, send keyid, recv keyid, counter, msg len, msg
* len of revealed mac keys, revealed mac keys, MAC */
buflen = 3 + (version == 2 ? 1 : 0) + 4 + 4 + 8 + 4 + msglen +
4 + reveallen + 20;
gcry_mpi_print(format, NULL, 0, &pubkeylen, context->our_dh_key.pub);
buflen += pubkeylen + 4;
buf = malloc(buflen);
msgbuf = gcry_malloc_secure(msglen);
if (buf == NULL || msgbuf == NULL) {
free(buf);
gcry_free(msgbuf);
gcry_free(msgdup);
return gcry_error(GPG_ERR_ENOMEM);
}
memmove(msgbuf, msgdup, justmsglen);
msgbuf[justmsglen] = '\0';
otrl_tlv_serialize(msgbuf + justmsglen + 1, tlvs);
bufp = buf;
lenp = buflen;
if (version == 1) {
memmove(bufp, "\x00\x01\x03", 3); /* header */
} else {
memmove(bufp, "\x00\x02\x03", 3); /* header */
}
debug_data("Header", bufp, 3);
bufp += 3; lenp -= 3;
if (version == 2) {
bufp[0] = flags;
bufp += 1; lenp -= 1;
}
write_int(context->our_keyid-1); /* sender keyid */
debug_int("Sender keyid", bufp-4);
write_int(context->their_keyid); /* recipient keyid */
debug_int("Recipient keyid", bufp-4);
write_mpi(context->our_dh_key.pub, pubkeylen, "Y"); /* Y */
otrl_dh_incctr(sess->sendctr);
memmove(bufp, sess->sendctr, 8); /* Counter (top 8 bytes only) */
debug_data("Counter", bufp, 8);
bufp += 8; lenp -= 8;
write_int(msglen); /* length of encrypted data */
debug_int("Msg len", bufp-4);
err = gcry_cipher_reset(sess->sendenc);
if (err) goto err;
err = gcry_cipher_setctr(sess->sendenc, sess->sendctr, 16);
if (err) goto err;
err = gcry_cipher_encrypt(sess->sendenc, bufp, msglen, msgbuf, msglen);
if (err) goto err; /* encrypted data */
debug_data("Enc data", bufp, msglen);
bufp += msglen;
lenp -= msglen;
gcry_md_reset(sess->sendmac);
gcry_md_write(sess->sendmac, buf, bufp-buf);
memmove(bufp, gcry_md_read(sess->sendmac, GCRY_MD_SHA1), 20);
debug_data("MAC", bufp, 20);
bufp += 20; /* MAC */
lenp -= 20;
write_int(reveallen); /* length of revealed MAC keys */
debug_int("Revealed MAC length", bufp-4);
if (reveallen > 0) {
memmove(bufp, context->saved_mac_keys, reveallen);
debug_data("Revealed MAC data", bufp, reveallen);
bufp += reveallen; lenp -= reveallen;
free(context->saved_mac_keys);
context->saved_mac_keys = NULL;
context->numsavedkeys = 0;
}
assert(lenp == 0);
/* Make the base64-encoding. */
base64len = ((buflen + 2) / 3) * 4;
base64buf = malloc(5 + base64len + 1 + 1);
if (base64buf == NULL) {
err = gcry_error(GPG_ERR_ENOMEM);
goto err;
}
memmove(base64buf, "?OTR:", 5);
otrl_base64_encode(base64buf+5, buf, buflen);
base64buf[5 + base64len] = '.';
base64buf[5 + base64len + 1] = '\0';
free(buf);
gcry_free(msgbuf);
*encmessagep = base64buf;
gcry_free(context->lastmessage);
context->lastmessage = NULL;
context->may_retransmit = 0;
if (msglen > 0) {
const char *prefix = "[resent] ";
size_t prefixlen = strlen(prefix);
if (!strncmp(prefix, msgdup, prefixlen)) {
/* The prefix is already there. Don't add it again. */
prefix = "";
prefixlen = 0;
}
context->lastmessage = gcry_malloc_secure(prefixlen + justmsglen + 1);
if (context->lastmessage) {
strcpy(context->lastmessage, prefix);
strcat(context->lastmessage, msgdup);
}
}
gcry_free(msgdup);
return gcry_error(GPG_ERR_NO_ERROR);
err:
free(buf);
gcry_free(msgbuf);
gcry_free(msgdup);
*encmessagep = NULL;
return err;
}
/* Recalculate the MAC on the message, base64-encode the resulting MAC'd
* message, and put on the appropriate header and footer. Return a
* newly-allocated pointer to the result, which the caller will have to
* free(). */
char *remac_datamsg(DataMsg datamsg, unsigned char mackey[20])
{
size_t rawlen, lenp;
size_t ylen;
size_t base64len;
char *outmsg;
unsigned char *raw, *bufp;
unsigned char version = datamsg->version;
/* Calculate the size of the message that will result */
gcry_mpi_print(GCRYMPI_FMT_USG, NULL, 0, &ylen, datamsg->y);
rawlen = 3 + (version == 3 ? 8 : 0) + (version == 2 ||
version == 3 ? 1 : 0) + 4 + 4 + 4 + ylen + 8 + 4 +
datamsg->encmsglen + 20 + 4 + datamsg->mackeyslen;
/* Construct the new raw message (note that some of the pieces may
* have been altered, so we construct it from scratch). */
raw = malloc(rawlen);
if (!raw) {
fprintf(stderr, "Out of memory!\n");
exit(1);
}
bufp = raw;
lenp = rawlen;
datamsg->macstart = raw;
datamsg->macend = NULL;
free(datamsg->raw);
datamsg->raw = raw;
datamsg->rawlen = rawlen;
memmove(bufp, "\x00", 1);
memmove(bufp+1, &version, 1);
memmove(bufp+2, "\x03", 1);
bufp += 3; lenp -= 3;
if (version == 3) {
write_int(datamsg->sender_instance);
write_int(datamsg->receiver_instance);
}
if (version == 2 || version == 3) {
bufp[0] = datamsg->flags;
bufp += 1; lenp -= 1;
}
write_int(datamsg->sender_keyid);
write_int(datamsg->rcpt_keyid);
write_mpi(datamsg->y, ylen);
write_raw(datamsg->ctr, 8);
write_int(datamsg->encmsglen);
write_raw(datamsg->encmsg, datamsg->encmsglen);
datamsg->macend = bufp;
/* Recalculate the MAC */
sha1hmac(datamsg->mac, mackey, datamsg->macstart,
datamsg->macend - datamsg->macstart);
write_raw(datamsg->mac, 20);
write_int(datamsg->mackeyslen);
write_raw(datamsg->mackeys, datamsg->mackeyslen);
if (lenp != 0) {
fprintf(stderr, "Error creating OTR Data Message.\n");
exit(1);
}
base64len = 5 + ((datamsg->rawlen + 2) / 3) * 4 + 1 + 1;
outmsg = malloc(base64len);
if (!outmsg) return NULL;
memmove(outmsg, "?OTR:", 5);
otrl_base64_encode(outmsg + 5, datamsg->raw, datamsg->rawlen);
strcpy(outmsg + base64len - 2, ".");
return outmsg;
}
/* Create a public key block from a private key */
static gcry_error_t make_pubkey(unsigned char **pubbufp, size_t *publenp,
gcry_sexp_t privkey)
{
gcry_mpi_t p,q,g,y;
gcry_sexp_t dsas,ps,qs,gs,ys;
size_t np,nq,ng,ny;
enum gcry_mpi_format format = GCRYMPI_FMT_USG;
unsigned char *bufp;
size_t lenp;
*pubbufp = NULL;
*publenp = 0;
/* Extract the public parameters */
dsas = gcry_sexp_find_token(privkey, "dsa", 0);
if (dsas == NULL) {
return gcry_error(GPG_ERR_UNUSABLE_SECKEY);
}
ps = gcry_sexp_find_token(dsas, "p", 0);
qs = gcry_sexp_find_token(dsas, "q", 0);
gs = gcry_sexp_find_token(dsas, "g", 0);
ys = gcry_sexp_find_token(dsas, "y", 0);
gcry_sexp_release(dsas);
if (!ps || !qs || !gs || !ys) {
gcry_sexp_release(ps);
gcry_sexp_release(qs);
gcry_sexp_release(gs);
gcry_sexp_release(ys);
return gcry_error(GPG_ERR_UNUSABLE_SECKEY);
}
p = gcry_sexp_nth_mpi(ps, 1, GCRYMPI_FMT_USG);
gcry_sexp_release(ps);
q = gcry_sexp_nth_mpi(qs, 1, GCRYMPI_FMT_USG);
gcry_sexp_release(qs);
g = gcry_sexp_nth_mpi(gs, 1, GCRYMPI_FMT_USG);
gcry_sexp_release(gs);
y = gcry_sexp_nth_mpi(ys, 1, GCRYMPI_FMT_USG);
gcry_sexp_release(ys);
if (!p || !q || !g || !y) {
gcry_mpi_release(p);
gcry_mpi_release(q);
gcry_mpi_release(g);
gcry_mpi_release(y);
return gcry_error(GPG_ERR_UNUSABLE_SECKEY);
}
*publenp = 0;
gcry_mpi_print(format, NULL, 0, &np, p);
*publenp += np + 4;
gcry_mpi_print(format, NULL, 0, &nq, q);
*publenp += nq + 4;
gcry_mpi_print(format, NULL, 0, &ng, g);
*publenp += ng + 4;
gcry_mpi_print(format, NULL, 0, &ny, y);
*publenp += ny + 4;
*pubbufp = malloc(*publenp);
if (*pubbufp == NULL) {
gcry_mpi_release(p);
gcry_mpi_release(q);
gcry_mpi_release(g);
gcry_mpi_release(y);
return gcry_error(GPG_ERR_ENOMEM);
}
bufp = *pubbufp;
lenp = *publenp;
write_mpi(p,np,"P");
write_mpi(q,nq,"Q");
write_mpi(g,ng,"G");
write_mpi(y,ny,"Y");
gcry_mpi_release(p);
gcry_mpi_release(q);
gcry_mpi_release(g);
gcry_mpi_release(y);
return gcry_error(GPG_ERR_NO_ERROR);
}
