/* Add padding and return the message digest. */ static void sha1_final(struct crypto_tfm *tfm, u8 *out) { struct crypt_s390_sha1_ctx *sctx = crypto_tfm_ctx(tfm); //must perform manual padding pad_message(sctx); crypt_s390_kimd(KIMD_SHA_1, sctx->state, sctx->buffer, sctx->buf_len); //copy digest to out memcpy(out, sctx->state, SHA1_DIGEST_SIZE); /* Wipe context */ memset(sctx, 0, sizeof *sctx); }
void string_read(char *s) { sha message; init(&message); int i=0; while(s[i]!='\0') { calculate(&message, s[i]); ++i; } pad_message(&message); disp(message); }
static int prepare_index(git_index *index, char* msg){ git_oid index_tree; git_tree *head_obj; git_reference *head; char tree_str[GIT_OID_HEXSZ+1], parent_str[GIT_OID_HEXSZ+1]; // Get the head OID git_repository_head(&head, repo); git_reference_peel((git_object**)&head_obj, head, GIT_OBJ_COMMIT); git_oid_tostr(parent_str, GIT_OID_HEXSZ+1, git_tree_id(head_obj)); git_reference_free(head); git_object_free((git_object*)head_obj); // Write the coin // TODO: Use C for this? system("perl -i -pe 's/(null:)(\\d+)/$1 . ($2+1)/e' LEDGER.txt"); system("grep -q \"null\" LEDGER.txt || echo \"null:1\" >> LEDGER.txt"); // Update the index check_lg2(git_index_read(index, 0), "Could not re-read index from disk", NULL); check_lg2(git_index_add_bypath(index, "LEDGER.txt"), "Could not add to index", "LEDGER.txt"); // Write the index and get the tree OID git_index_write_tree(&index_tree, index); git_oid_tostr(tree_str, GIT_OID_HEXSZ+1, &index_tree); snprintf(msg, BUFFER_LENGTH, "commit %d%c" "tree %s\n" "parent %s\n" "author null <*****@*****.**> %d +0000\n" "committer null <*****@*****.**> %d +0000\n" "\n" "coins now" "\x01\x01\x01\x01" "\x01\x01\x01\x01" "\x01\x01\x01", // Align 32 bit words on GPU MSG_LENGTH, 0, tree_str, parent_str, (int)time(NULL), (int)time(NULL)); pad_message(msg, COMMIT_LENGTH, BUFFER_LENGTH); return 0; }
/** * @param [out] message_digest_array Integer array to store the message in * @return Whether or not the extraction was sucessful */ bool get_raw_digest(uint32_t * message_digest_array) { if (corrupted) { return false; } if (!computed) { pad_message(); computed = true; } for (int i = 0; i < 5; i++) { message_digest_array[i] = H[i]; } return true; }
/* Add padding and return the message digest */ static void sha256_final(struct crypto_tfm *tfm, u8 *out) { struct s390_sha256_ctx *sctx = crypto_tfm_ctx(tfm); /* must perform manual padding */ pad_message(sctx); crypt_s390_kimd(KIMD_SHA_256, sctx->state, sctx->buf, sctx->count / 8); /* copy digest to out */ memcpy(out, sctx->state, SHA256_DIGEST_SIZE); /* wipe context */ memset(sctx, 0, sizeof *sctx); }
void file_read(char *s) { sha message; init(&message); FILE *fp; fp = fopen(s,"rb"); char c; c = getc(fp); while(!feof(fp)) { calculate(&message,c); c = getc(fp); } pad_message(&message); disp(message); fclose(fp); }
/************************************************************************** Description: This function builds and sends the message with the current clutter censor zones. Input: file_num - The file number to be edited. Output: Clutter censor zone message. Returns: Message sent = 1, Not sent = -1 Notes: **************************************************************************/ static int rms_send_legacy_clutter_zone_msg(ushort file_num) { RPG_clutter_regions_msg_t *clutter_files; char *Clutter_data; UNSIGNED_BYTE msg_buf[MAX_BUF_SIZE]; UNSIGNED_BYTE *msg_buf_ptr; int msg_length = 0; int ret, i; ushort num_halfwords; short temp_short; /* Set pointer to beginning of buffer */ msg_buf_ptr = msg_buf; /* Place pointer past header */ msg_buf_ptr += MESSAGE_START; /* Put file number in output buffer */ conv_ushort_unsigned(msg_buf_ptr,(ushort*)&file_num); msg_buf_ptr += PLUS_SHORT; /* Read clutter zone data from clutter zones LB */ ret = ORPGCCZ_get_censor_zones( ORPGCCZ_LEGACY_ZONES, (char **) &Clutter_data, ORPGCCZ_DEFAULT ); if (ret != sizeof (RPG_clutter_regions_msg_t)) { LE_send_msg (RMS_LE_ERROR, "ORPGCCZ_get_censor_zones failed (ORPGCCZ_LEGACY_ZONES) in edit clutter command (ret %d)", ret); return(-1); } /* Assign clutter data to clutter files structure */ clutter_files = (RPG_clutter_regions_msg_t *) Clutter_data; /* Temporarily assigning last file downloaded until coordination with FAA is accomplished */ file_num = clutter_files->last_dwnld_file; /* Place zones in output buffer */ for (i=0; i<=clutter_files->file[file_num].regions.regions; i++) { /* Place start range in message */ temp_short = clutter_files->file[file_num].regions.data[i].start_range; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; /* Place stop range in message */ temp_short = clutter_files->file[file_num].regions.data[i].stop_range; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; /* Place start azimuth in message */ temp_short =clutter_files->file[file_num].regions.data[i].start_azimuth; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; /* Place stop azimuth in message */ temp_short =clutter_files->file[file_num].regions.data[i].stop_azimuth; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; /* Place segment number in message */ temp_short =clutter_files->file[file_num].regions.data[i].segment; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; /* Place select code in message */ temp_short =clutter_files->file[file_num].regions.data[i].select_code; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; /* Place doppler level in message */ temp_short =clutter_files->file[file_num].regions.data[i].doppl_level; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; /* Place surviellance level in message */ temp_short =clutter_files->file[file_num].regions.data[i].surv_level; conv_short_unsigned(msg_buf_ptr, &temp_short); msg_buf_ptr += PLUS_SHORT; } /* End for loop */ /* Pad the message if necessary */ if (i < MAX_NUMBER_CLUTTER_ZONES) { msg_length = msg_buf_ptr - msg_buf; pad_message(msg_buf_ptr, msg_length, MAX_CLUTTER_LENGTH); } /* Place pointer to end of message */ msg_buf_ptr += (MAX_CLUTTER_LENGTH - msg_length); /* Add terminator to the message */ add_terminator(msg_buf_ptr); msg_buf_ptr += PLUS_INT; /* Compute the number of halfwords in the message */ num_halfwords = ((msg_buf_ptr - msg_buf) / 2); /* Add header to message */ ret = build_header(&num_halfwords, STATUS_TYPE, msg_buf, 0); if (ret != 1){ LE_send_msg (RMS_LE_ERROR, "Build RMMS msg header failed for clutter censor zone"); return (-1); } /* Send the message to the FAA/RMMS */ ret = send_message(msg_buf,STATUS_TYPE,RMS_STANDARD); if (ret != 1){ LE_send_msg (RMS_LE_ERROR, "Send RMMS message failed (ret %d) for clutter censor zones", ret); return (-1); } /* Lock the clutter zone msg so someone else cannot edit until RMS is done */ ret = ORPGCCZ_set_edit_lock( ORPGCCZ_LEGACY_ZONES ); if ( ret == ORPGEDLOCK_LOCK_UNSUCCESSFUL) { LE_send_msg(RMS_LE_ERROR,"Unable to lock CENSOR ZONES LGCY"); return (ret); } else{ LE_send_msg(RMS_LE_ERROR,"CENSOR ZONES LGCY locked"); clutter_zones_locked = 1; } return (1); } /*End build clutter */
int main(int argc, char **argv){ int i, j; char unused_stop = 0; int iters = 10; hash_args args; char msg[BUFFER_LENGTH]; unsigned char hash[SHA_DIGEST_LENGTH]; char hex_hash[SHA_DIGEST_LENGTH*2]; char hex_difficulty[SHA_DIGEST_LENGTH*2] = "00000008ffffffffffffffffffffffffffffffff"; unsigned char difficulty; struct timeval start, end, diff; unsigned long total = 0, curr; // Fill in some deterministic data for(i = 0; i < BUFFER_LENGTH; i++){ msg[i] = i % 128; } pad_message(msg, COMMIT_LENGTH, BUFFER_LENGTH); args.stop = &unused_stop; args.msg = (char*)msg; if(argc > 1){ iters = atoi(argv[1]); } if(argc > 2){ memcpy(hex_difficulty, argv[2], SHA_DIGEST_LENGTH*2); } difficulty = parse_difficulty(hex_difficulty); printf("Starting benchmark with difficulty %02x\n", difficulty); init_hasher(difficulty); for(i = 0; i < iters; i++){ memset(msg, 0, COMMIT_LENGTH); *((int*)(&(msg[0]))) = i; args.found = 0; cudaProfilerStart(); gettimeofday(&start, NULL); force_hash(&args); gettimeofday(&end, NULL); cudaProfilerStop(); timersub(&end, &start, &diff); curr = diff.tv_sec * 1000 + diff.tv_usec / 1000; total += curr; SHA1(msg, COMMIT_LENGTH, hash); for(j=0; j < 20; j++){ sprintf(&hex_hash[j*2], "%02x", hash[j] & 0xff); } if(memcmp(hex_hash, hex_difficulty, SHA_DIGEST_LENGTH*2) > 0){ printf("Msg:"); for(j = 0; j < BUFFER_LENGTH; j++){ printf("%02x", msg[j] & 0xff); } printf("\nBad hash: %.40s\n", hex_hash); exit(1); } else { printf("Successful run in %ld ms: %.40s\n", curr, hex_hash); } if(!args.found){ puts("Failed to find a hash!"); exit(1); } printf("\n"); } printf("\n%ld ms per iteration (%d iters, %.40s difficulty)\n", total / iters, iters, hex_difficulty); free_hasher(); exit(0); }
void rms_send_free_text_msg () { UNSIGNED_BYTE free_text_buf[MAX_BUF_SIZE]; UNSIGNED_BYTE *free_text_buf_ptr; char *Msg; int ret, i, msg_size; LB_info info; ushort message_size_halfwords, num_halfwords; /* Search for the latest free text message. */ if((ret = ORPGDA_seek(ORPGDAT_RMS_TEXT_MSG, 0, LB_LATEST, &info)) < 0) { LE_send_msg(RMS_LE_ERROR, "Failed seek RMMS free text message (%d).\n", ret ); }else { /* Allocate memory for the message. */ Msg = (char*)malloc(info.size); /* Read the latest message. */ ret = ORPGDA_read (ORPGDAT_RMS_TEXT_MSG, (char *) Msg, info.size, info.id); if(ret <0 ){ LE_send_msg(RMS_LE_ERROR, "Failed read RMMS free text message (%d).\n", ret ); }else { /* Set the pointer to beginning of buffer */ free_text_buf_ptr = free_text_buf; /* Set the pointer past the header */ free_text_buf_ptr += MESSAGE_START; /* Compute the size of the free text string in halfwords */ message_size_halfwords = (info.size/2); /* Adjust for rounding */ message_size_halfwords += (info.size%2); /* Put free text string size in output buffer */ conv_ushort_unsigned(free_text_buf_ptr,&message_size_halfwords); free_text_buf_ptr += PLUS_SHORT; /* Put free text string in output buffer */ for (i=0; i< info.size; i++){ conv_char_unsigned(free_text_buf_ptr, &Msg[i], PLUS_BYTE); free_text_buf_ptr += PLUS_BYTE; } /* End loop */ /* Compute the size of the message */ msg_size = (free_text_buf_ptr - free_text_buf); /* Pad the message */ pad_message (free_text_buf_ptr, msg_size, TEXT_PAD_SIZE); free_text_buf_ptr += (TEXT_PAD_SIZE - msg_size); /* Add the terminator to the message */ add_terminator(free_text_buf_ptr); free_text_buf_ptr += PLUS_INT; /* Compute the size of the message in halfwords */ num_halfwords = ((free_text_buf_ptr - free_text_buf) / 2); /* Add header to message */ ret = build_header(&num_halfwords, FREE_TYPE, free_text_buf, 0); if (ret != 1){ LE_send_msg (RMS_LE_ERROR, "RMS build header failed for rms send free text message"); } /* End if */ /* Send message to the FAA/RMMs */ ret = send_message(free_text_buf,FREE_TYPE,RMS_STANDARD); if (ret != 1){ LE_send_msg (RMS_LE_ERROR, "Send message failed (ret %d) for rms send free text message", ret); } /* end if */ } /* End else */ free(Msg); } /* End else */ } /*End rms send free text msg */
#include "../src/common.h" #include "../src/hash.h" TEST_CASE("Test message padding", "[hash]") { message_t message_1(8, 0xff); // should pad to 16 bytes message_t message_2(16, 0xff); // should pad to 24 bytes message_t message_3(13, 0xff); // should pad to 16 bytes message_t message_4(17, 0xff); // should pad to 24 bytes SECTION("Pads if message length divides by 8 bytes") { REQUIRE(pad_message(message_1).size() == 16); REQUIRE(pad_message(message_2).size() == 24); } SECTION("Pads if message length does not divide by 8 bytes") { REQUIRE(pad_message(message_3).size() == 16); REQUIRE(pad_message(message_4).size() == 24); } SECTION("Adds correct padding bits") { REQUIRE(pad_message(message_1)[8] == 0x80); REQUIRE(pad_message(message_4)[17] == 0x80); } }