/* Given a int ptr, it will unpack an array of size_val
*/
int unpack16_array(uint16_t ** valp, uint32_t * size_val, Buf buffer)
{
uint32_t i = 0;
if (unpack32(size_val, buffer))
return SLURM_ERROR;
*valp = xmalloc((*size_val) * sizeof(uint16_t));
for (i = 0; i < *size_val; i++) {
if (unpack16((*valp) + i, buffer))
return SLURM_ERROR;
}
return SLURM_SUCCESS;
}
int unpacklongdouble_array(long double **valp, uint32_t* size_val, Buf buffer)
{
uint32_t i = 0;
if (unpack32(size_val, buffer))
return SLURM_ERROR;
*valp = xmalloc_nz((*size_val) * sizeof(long double));
for (i = 0; i < *size_val; i++) {
if (unpacklongdouble((*valp) + i, buffer))
return SLURM_ERROR;
}
return SLURM_SUCCESS;
}
uint8_t* SshAgentProcessUnlockRequest(SshAgentContext* context, uint8_t* request, int requestSize)
{
if (context->isLocked == 0)
{
return SshAgentMakeErrorReply();
}
int passwordLength = unpack32(request + 1);
if (strncmp(context->lockPassword, (char*)request + 5, passwordLength) != 0)
{
return SshAgentMakeErrorReply();
}
context->isLocked = 0;
free(context->lockPassword);
context->lockPassword = NULL;
return SshAgentMakeSuccessReply();
}
uint8_t* SshAgentProcessLockRequest(SshAgentContext* context, uint8_t* request, int requestSize)
{
if (context->isLocked)
{
return SshAgentMakeErrorReply();
}
int passwordLength = unpack32(request + 1);
context->lockPassword = malloc(passwordLength + 1);
if (context->lockPassword == NULL)
{
return SshAgentMakeErrorReply();
}
memcpy(context->lockPassword, request + 5, passwordLength);
context->lockPassword[passwordLength] = 0;
context->isLocked = 1;
return SshAgentMakeSuccessReply();
}
std::string sha256::hash_string( void )
{
if ( !_finalized )
finalize();
std::string result;
uint8_t buf[4];
char tmp[3];
for ( size_t i = 0 ; i < 8; i++ )
{
unpack32( _hash[i], buf );
for ( size_t j = 0; j < 4; ++j )
{
sprintf( tmp, "%02x", uint32_t(buf[j]) );
result.append( tmp, tmp+2 );
}
}
return result;
}
uint8_t* SshAgentMakeSignatureReply(SshAgentContext* context, uint8_t* request, int requestSize)
{
if (context->isLocked)
{
return SshAgentMakeErrorReply();
}
// Find the private key matching the public key from the request.
int publicBlobIndex = 1;
uint32_t publicBlobSize = unpack32(request + publicBlobIndex);
int dataIndex = publicBlobIndex + 4 + publicBlobSize;
uint32_t dataSize = unpack32(request + dataIndex);
int flagsIndex = dataIndex + 4 + dataSize;
uint32_t flags;
memcpy(&flags, request + flagsIndex, 4);
if (flags != 0)
{
return SshAgentMakeErrorReply();
}
int i;
for (i = 0; i < context->keyCount; i++)
{
ssh_string blob;
int sshResult = ssh_pki_export_pubkey_blob(context->keys[i], &blob);
if (sshResult == SSH_OK)
{
int cmpResult = memcmp(request + publicBlobIndex, blob, publicBlobSize);
ssh_string_free(blob);
if (cmpResult == 0)
{
break;
}
}
}
if (i >= context->keyCount)
{
return SshAgentMakeErrorReply();
}
// Sign the data and return it in a message of the form:
// messageLength[ SSH2_AGENT_SIGN_RESPONSE signatureBlob]
ssh_string signatureBlob = SshAgentSign(request + dataIndex + 4, dataSize, context->keys[i], flags);
if (signatureBlob == NULL)
{
return SshAgentMakeErrorReply();
}
uint32_t signatureBlobLength = unpack32((uint8_t*)signatureBlob);
int messageLength = 5 + signatureBlobLength;
uint8_t* message = malloc(messageLength + 4);
if (message == NULL)
{
free(signatureBlob);
return SshAgentMakeErrorReply();
}
pack32(message, messageLength);
message[4] = SSH2_AGENT_SIGN_RESPONSE;
memcpy(message + 5, signatureBlob, signatureBlobLength + 4);
free(signatureBlob);
return message;
}
int main (int argc, char *argv[])
{
Buf buffer;
uint16_t test16 = 1234, out16;
uint32_t test32 = 5678, out32, byte_cnt;
char testbytes[] = "TEST BYTES", *outbytes;
char teststring[] = "TEST STRING", *outstring = NULL;
char *nullstr = NULL;
char *data;
int data_size;
long double test_double = 1340664754944.2132312, test_double2;
uint64_t test64;
buffer = init_buf (0);
pack16(test16, buffer);
pack32(test32, buffer);
pack64((uint64_t)test_double, buffer);
packstr(testbytes, buffer);
packstr(teststring, buffer);
packstr(nullstr, buffer);
packstr("literal", buffer);
packstr("", buffer);
data_size = get_buf_offset(buffer);
printf("wrote %d bytes\n", data_size);
/* Pull data off old buffer, destroy it, and create a new one */
data = xfer_buf_data(buffer);
buffer = create_buf(data, data_size);
unpack16(&out16, buffer);
TEST(out16 != test16, "un/pack16");
unpack32(&out32, buffer);
TEST(out32 != test32, "un/pack32");
unpack64(&test64, buffer);
test_double2 = (long double)test64;
TEST((uint64_t)test_double2 != (uint64_t)test_double, "un/pack double as a uint64");
/* info("Original\t %Lf", test_double); */
/* info("uint64\t %ld", test64); */
/* info("converted LD\t %Lf", test_double2); */
unpackstr_ptr(&outbytes, &byte_cnt, buffer);
TEST( ( strcmp(testbytes, outbytes) != 0 ) , "un/packstr_ptr");
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp(teststring, outstring) != 0, "un/packstr_xmalloc");
xfree(outstring);
unpackstr_xmalloc(&nullstr, &byte_cnt, buffer);
TEST(nullstr != NULL, "un/packstr of null string.");
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp("literal", outstring) != 0,
"un/packstr of string literal");
xfree(outstring);
unpackstr_xmalloc(&outstring, &byte_cnt, buffer);
TEST(strcmp("", outstring) != 0, "un/packstr of string \"\" ");
xfree(outstring);
free_buf(buffer);
totals();
return failed;
}
