int
solve_query(int32_t *s, int32_t *sa, int32_t *q, int d, int m, int k,
int32_pair_t *rv)
{
int j, ltk, nv;
int *filter = malloc(sizeof(int)*d);
memset(filter, 0xff, sizeof(int)*d);
ltk = nv = 0;
for (int ik = 0; ik < m+1 - m/k; ik += m/k) {
int r = sa_search_low(sa, s, d*(m+1), q + ik, m/k);
int t = sa_search_high(sa, s, d*(m+1), q + ik, m/k);
for(; r < t && nv < d; r++) {
j = sa[r]/(m+1);
if (sa[r]%(m+1) == ik && filter[j] != 1) {
filter[j] = 1;
nv ++;
int x = hamming_distance(q, s + j*(m+1), m, k, ik);
if (x < k) {
rv[ltk].id = j;
rv[ltk].n = x;
ltk++;
}
}
}
}
free(filter);
fprintf(stderr, "#hits: %d (%d)\n", ltk, nv);
return ltk;
}
double norm_hamming_distance(const unsigned char *in, unsigned int in_length, unsigned int key_length)
{
unsigned int num_blocks;
unsigned int hamming = 0;
double hamming_norm = 0;
unsigned int i, j, k;
unsigned char tmp1[key_length];
unsigned char tmp2[key_length];
num_blocks = in_length / key_length;
j = 0;
for(k=0; k<num_blocks; k++) {
for(i=0; i<key_length; i++) {
tmp1[i] = in[i+k*key_length];
tmp2[i] = in[(i+k*key_length+key_length)%in_length];
}
hamming += hamming_distance(tmp1, tmp2, key_length);
}
hamming_norm = (double) hamming / (double) num_blocks / (double) key_length;
// printf("num_blocks = %d, key_len = %d, hamming = %d, hamming_norm = %f\n", num_blocks, key_length, hamming, hamming_norm);
return hamming_norm;
}
static unsigned int get_key_len(const unsigned char *buf, size_t len,
size_t key_max_len)
{
unsigned int key_len, best_key_len = 0;
unsigned int nblocks, block1, block2;
unsigned int hamming;
float score, best_score = GET_KEY_LEN_NOSCORE;
for (key_len = 2; key_len < key_max_len; key_len++) {
hamming = 0;
nblocks = len / key_len;
if (nblocks < GET_LEY_LEN_MINBLOCKS)
break;
for (block1 = 0; block1 < nblocks; block1++)
for (block2 = block1 + 1; block2 < nblocks; block2++)
hamming += hamming_distance(
&buf[key_len * block1],
&buf[key_len * block2],
key_len
);
score = (float)hamming /
(key_len * (nblocks * (nblocks - 1) / 2));
if (score < best_score || best_score == GET_KEY_LEN_NOSCORE) {
best_score = score;
best_key_len = key_len;
}
}
return best_key_len;
}
void
build_table()
{
int i;
int j;
for (i=0; i < TABLE_SIZE; ++i)
for (j=0; j < TABLE_SIZE; ++j)
HAM_TABLE[i][j] = hamming_distance(i, j);
}
long hamming_test()
{
char *word1 = "this is a test";
char *word2 = "wokka wokka!!!";
long result = hamming_distance(word1, word2, 14);
if(result == 37)
printf("Hamming Test successful");
else
printf("Hamming Test unsuccessful");
printf(" with %ld\n", result);
}
void pdist_hamming(const double *X, double *dm, int m, int n) {
int i, j;
const double *u, *v;
double *it = dm;
for (i = 0; i < m; i++) {
for (j = i + 1; j < m; j++, it++) {
u = X + (n * i);
v = X + (n * j);
*it = hamming_distance(u, v, n);
}
}
}
void cdist_hamming(const double *XA,
const double *XB, double *dm, int mA, int mB, int n) {
int i, j;
const double *u, *v;
double *it = dm;
for (i = 0; i < mA; i++) {
for (j = 0; j < mB; j++, it++) {
u = XA + (n * i);
v = XB + (n * j);
*it = hamming_distance(u, v, n);
}
}
}
int test_hamming_distance(int argc, char *argv[])
{
if (argc != 3){
std::cout << "Usage: ch6 <str1> <str2>" << std::endl;
return -1;
}
string str1 {argv[1]};
string str2 {argv[2]};
std::cout << hamming_distance(str1, str2) << std::endl;
return 0;
}
int main() {
char str1[MAX_DNA];
char str2[MAX_DNA];
FILE *fp = fopen("rosalind_point_mutations.txt", "r");
fgets(str1, MAX_DNA, fp);
fgets(str2, MAX_DNA, fp);
printf("The hamming distance is:\n");
printf("%d\n", hamming_distance(str1, str2));
return 0;
}
static PyObject * jellyfish_hamming_distance(PyObject *self, PyObject *args)
{
const char *s1, *s2;
unsigned result;
if (!PyArg_ParseTuple(args, "ss", &s1, &s2)) {
return NULL;
}
result = hamming_distance(s1, s2);
return Py_BuildValue("I", result);
}
/**
* delete_search
*
* Terminate the current search and free all the memory involved.
*/
void Wordrec::delete_search(SEARCH_RECORD *the_search) {
float closeness;
closeness = (the_search->num_joints ?
(hamming_distance(reinterpret_cast<uinT32*>(the_search->first_state),
reinterpret_cast<uinT32*>(the_search->best_state), 2) /
(float) the_search->num_joints) : 0.0f);
free_state (the_search->first_state);
free_state (the_search->best_state);
free_hash_table(the_search->closed_states);
FreeHeapData (the_search->open_states, (void_dest) free_state);
memfree(the_search);
}
int main () {
ulong *f1;
ulong *f2;
ulong i, j, m; /* M is the number of variables in the boolean function */
printf ("Enter the number of variables in your boolean function: ");
scanf ("%lu", &m);
f1 = allocate_table (m);
f2 = allocate_table (m);
ulong n = 1UL << m;
for ( j = 0; j < 2; j++ ) {
for ( i = 0; i < n; i++ ) {
printf ("Enter the [%lu] boolean value of [%lu] boolean table: ", i, j);
if ( j == 0) {
scanf ("%lu", &f1[i]);
if ( f1[i] != 0 && f1[i] != 1 ) {
printf ("Program accepts only boolean values[0/1]\n");
i = i - 1;
}
}
else {
scanf ("%lu", &f2[i]);
if ( f2[i] != 0 && f2[i] != 1 ) {
printf ("Program accepts only boolean values[0/1]\n");
i = i - 1;
}
}
}
}
printf ("\nTruth Table\n");
printf ("f1\tf2\n");
for ( i = 0; i < n; i++ ) {
for ( j = 0; j < 2; j++ ) {
if ( j == 0 )
printf ("%lu\t", f1[i]);
else
printf ("%lu\n", f2[i]);
}
}
printf ("\nThe hamming distance of the two tables is %lu\n", hamming_distance(f1, f2, m));
free(f1);
free(f2);
return 0;
}
/*
* Find the most likely key size for some repeated key xor'd cipher text up
* to a certain maximum key size. Based on the hamming distance between blocks.
* See http://crypto.stackexchange.com/a/8118 for why that is.
* @param cipher_text pointer to cipher text
* @param len length of cipher text
* precondition: length of cipher text >= len
* currently, also require that len >= 6 * max_key_size because that's
* how many blocks it's taking to get accurate results
* @param max_key_size largest key size to check
* @return most likely key size for the given cipher text
*/
static uint8_t find_likely_key_size(const uint8_t *cipher_text, size_t len,
size_t max_key_size)
{
if (!cipher_text)
return 0;
assert(len >= 6 * max_key_size); // TODO - handle this
size_t likely_key_size = 0;
uint32_t min_hamming = UINT32_MAX;
for (size_t key_size = 1; key_size <= max_key_size; ++key_size) {
uint32_t hamming = 0;
// Take 6 block's worth - that was the smallest size that worked...
for (size_t i = 0; i < 6; i++) {
hamming += hamming_distance(cipher_text + 2 * i * key_size,
cipher_text + (2 * i + 1) * key_size, key_size);
}
hamming = hamming * 100 / key_size; // 100 is just a rounding factor
if (hamming < min_hamming) {
min_hamming = hamming;
likely_key_size = key_size;
}
}
return likely_key_size;
}
int main(int argc, char* argv[]){
printf("~~~~~~~~BREAK REPEATING KEY XOR~~~~~~~~\n");
//Read in file to memory
char* file_b64;
FILE* fp;
int file_length = 0;
fp = fopen(encrypted_file, "r");
if (fp == NULL){
printf("ERROR: Cannot open encrypted file, %s\n", encrypted_file);
return 1;
}
char* line;
ssize_t read;
size_t len;
//Get length of file
while ((read = getline(&line, &len, fp)) != -1){
//Remove trailing newline
line = strsep(&line, "\n");
file_length += strlen(line);
}
fseek(fp, 0, SEEK_SET);
file_b64 = malloc(file_length);
while ((read = getline(&line, &len, fp)) != -1){
//Remove trailing newline
line = strsep(&line, "\n");
strcat(file_b64, line);
}
/*
fseek(fp, 0, SEEK_END);
file_length = ftell(fp);
fseek(fp, 0, SEEK_SET);
file_b64 = malloc(file_length);
fread(file_b64, 1, file_length, fp);
*/
fclose(fp);
//Decode base64 into memory
unsigned char* data;
decode_base64(&data, file_b64);
//Find the key size
unsigned int KEYSIZE = 0;
int hd;
float normalized;
float lowest = FLT_MAX;
for (unsigned int key_size = 2; key_size <= 40; ++key_size){
//Hamming Distance of every combination of 1st 4 blocks of key_size
hd = hamming_distance(data, data+(key_size), key_size);
hd += hamming_distance(data, data+(2*key_size), key_size);
hd += hamming_distance(data, data+(3*key_size), key_size);
hd += hamming_distance(data+key_size, data+(2*key_size), key_size);
hd += hamming_distance(data+key_size, data+(3*key_size), key_size);
hd += hamming_distance(data+(2*key_size), data+(3*key_size), key_size);
normalized = (float)hd/key_size;
if (normalized < lowest) {
lowest = normalized;
KEYSIZE = key_size;
}
// printf("DEBUG: key size %d - hd %f\n", key_size, normalized);
}
if (KEYSIZE == 0) {
printf("ERROR: Could not find a keysize\n");
return 1;
}
printf("KEYSIZE = %d\n", KEYSIZE);
//Allocate space for a key
unsigned char* key = malloc(KEYSIZE);
//Break each byte of the key individually
for (unsigned int i = 0; i < KEYSIZE; ++i){
//Create block of every ith KEYSIZE block
size_t tb_size = get_base64_decoded_length(file_b64)/KEYSIZE;
tb_size++;
// if (i < get_base64_decoded_length(file_b64)%KEYSIZE) tb_size++;
unsigned char* transposed_block = malloc(tb_size);
unsigned int file_index = i;
for (unsigned int j = 0; j < tb_size; ++j){
memcpy(transposed_block+j,data+file_index,1);
file_index += KEYSIZE;
}
//Find single byte key for transposed block
float lowest_score = 0;
float second_lowest_score = 0;
unsigned int lowest_score_key = 256;
unsigned int second_lowest_score_key = 256;
unsigned char* result = malloc(tb_size);
for (unsigned int k = 0; k < 256; ++k){
repeated_xor( result,
transposed_block, tb_size,
(unsigned char *)&k, 1);
float score = score_letter_frequency_adams_way((char *)result, tb_size);
if (score != 0 && score > lowest_score){
second_lowest_score = lowest_score;
second_lowest_score_key = lowest_score_key;
lowest_score = score;
lowest_score_key = k;
}
}
memcpy(key+i,&lowest_score_key,1);
printf("INDEX %2d: %3d (%c)\n", i, lowest_score_key, lowest_score_key);
// printf("LOWEST: %c - %f SECOND LOWEST: %c - %f\n",
// lowest_score_key, lowest_score,
// second_lowest_score_key, second_lowest_score);
free(result);
free(transposed_block);
}
printf("%s\n", key);
//Decrypt data
unsigned char* decrypted_data = malloc(get_base64_decoded_length(file_b64));
repeated_xor( decrypted_data,
data, get_base64_decoded_length(file_b64),
key, KEYSIZE);
printf("%s\n", decrypted_data);
free(key);
free(data);
free(file_b64);
return 0;
}
bool
improve_AML_star(std::string &a,
std::string &b,
std::string &c,
std::string ¢er,
sequence_model model){
if ( model != JC && model != P_DISTANCE )
PROG_ERROR("not supported");
double slen = 1.0*a.length();
double hamdist;
//----------------
//current likelihood
double currL = 0.0;
//likelihood for a-center
hamdist = hamming_distance(a,center);
currL += compute_JC_log_likelihood_max05(hamdist,slen);
//likelihood for b-center
hamdist = hamming_distance(b,center);
currL += compute_JC_log_likelihood_max05(hamdist,slen);
//likelihood for c-center
hamdist = hamming_distance(c,center);
currL += compute_JC_log_likelihood_max05(hamdist,slen);
//-----------------
//a likelihoood
double aL = 0.0;
double bL = 0.0;
double cL = 0.0;
double tmp;
//a-b
hamdist = hamming_distance(a,b);
tmp = compute_JC_log_likelihood_max05(hamdist,slen);
aL += tmp;
bL += tmp;
//a-c
hamdist = hamming_distance(a,c);
tmp = compute_JC_log_likelihood_max05(hamdist,slen);
aL+=tmp;
cL+=tmp;
//b-c
hamdist = hamming_distance(b,c);
tmp = compute_JC_log_likelihood_max05(hamdist,slen);
cL += tmp;
bL += tmp;
//--------------
//parsimony
double parsimonyL=find_most_likely_parsimonious(a,b,c,center);
// PRINT(currL);PRINT(aL);PRINT(bL);PRINT(cL);PRINT(parsimonyL);
//---------------
//find maximum
double max_l = parsimonyL;
std::string *maxstr = ¢er;
if ( aL > max_l ){
maxstr = &a;
max_l = aL;
}
if ( bL > max_l ){
maxstr = &b;
max_l = bL;
}
if ( cL > max_l ){
maxstr = &c;
max_l = cL;
}
//if parsimony not min copy the correct one
if ( maxstr != ¢er ){
center.clear();
center.append(*maxstr);
}
if ( max_l - currL > 0.00001 ){
//PRINT(currL - max_l);PRINT(currL -aL);
return true;
}
return false;
}
void
FoldingEngine<SEQ>::
stochastic_fold(const std::string& name, const SEQ& seq, uint num_samples,
const std::vector<float>& gamma, uint max_clusters, std::ostream& out,
const std::string& p_outname, float th)
{
std::vector<BPvecPtr> bpv;
stochastic_fold(seq, num_samples, bpv);
if (max_clusters>=2)
{
// calculate the distance matrix
typedef boost::multi_array<double, 2> DMatrix;
DMatrix dmatrix(boost::extents[bpv.size()][bpv.size()]);
for (uint i=0; i!=bpv.size(); ++i)
for (uint j=i; j!=bpv.size(); ++j)
dmatrix[i][j]=dmatrix[j][i]=hamming_distance(*bpv[i], *bpv[j]);
// hierarchical clustering by DIANA
HCLUST::Diana<DMatrix> diana(dmatrix);
diana.build(max_clusters);
uint opt_n = diana.optimal_size();
std::vector<uint> res;
std::vector<uint> num;
diana.get_clusters(opt_n, res, num);
// sort by size of clusters
std::vector<uint> s(num.size(), 0);
std::vector<uint> idx(num.size());
for (uint i=0; i!=num.size(); ++i)
{
idx[i]=i;
if (i!=0) s[i]=s[i-1]+num[i-1];
}
std::sort(idx.begin(), idx.end(), cmp_by_size(num));
// centroid estimation for each cluster
for (uint i=0; i!=idx.size(); ++i)
{
std::vector<BPvecPtr> v(num[idx[i]]);
for (uint j=0; j!=v.size(); ++j) v[j] = bpv[res[s[idx[i]]+j]];
CountBP< std::vector<BPvecPtr> > count_bp(v, seq.size());
inside_traverse(0, seq.size()-1, count_bp);
char buf[100];
sprintf(buf, "%3.1f%%", static_cast<float>(num[idx[i]])/bpv.size()*100);
out << ">" << name << " (" << i+1 << " of " << num.size() << ", size="
<< buf << ")" << std::endl
<< get_seq(seq) << std::endl;
std::vector<float>::const_iterator g;
for (g=gamma.begin(); g!=gamma.end(); ++g) {
std::string paren(seq.size(), '.');
Centroid::execute(count_bp.table, paren, *g);
out << paren << " (g=" << *g << ",th=" << (1.0/(1.0+*g));
#ifdef HAVE_LIBRNA
out << ",e=" << calc_energy(seq, paren);
#endif
out << ")" << std::endl;
}
if (!p_outname.empty())
{
char buf[1024];
snprintf(buf, sizeof(buf), "%s-%d", p_outname.c_str(), i);
count_bp.table.save(buf, get_seq(seq), th);
}
}
}
else
{
CountBP< std::vector<BPvecPtr> > count_bp(bpv, seq.size());
inside_traverse(0, seq.size()-1, count_bp);
std::string paren(seq.size(), '.');
std::vector<float>::const_iterator g;
out << ">" << name << std::endl
<< get_seq(seq) << std::endl;
for (g=gamma.begin(); g!=gamma.end(); ++g)
{
std::fill(paren.begin(), paren.end(), '.');
Centroid::execute(count_bp.table, paren, *g);
out << paren << " (g=" << *g << ",th=" << (1.0/(1.0+*g));
#ifdef HAVE_LIBRNA
out << ",e=" << calc_energy(seq, paren);
#endif
out << ")" << std::endl;
}
if (!p_outname.empty())
{
char buf[1024];
snprintf(buf, sizeof(buf), "%s-1", p_outname.c_str());
count_bp.table.save(buf, get_seq(seq), th);
}
}
}
bool transposition_based_synthesis( circuit& circ, const binary_truth_table& spec,
properties::ptr settings, properties::ptr statistics )
{
// Settings parsing
// Run-time measuring
timer<properties_timer> t;
if ( statistics )
{
properties_timer rt( statistics );
t.start( rt );
}
unsigned bw = spec.num_outputs();
circ.set_lines( bw );
copy_metadata( spec, circ );
std::map<unsigned, unsigned> values_map;
for ( binary_truth_table::const_iterator it = spec.begin(); it != spec.end(); ++it )
{
binary_truth_table::cube_type in( it->first.first, it->first.second );
binary_truth_table::cube_type out( it->second.first, it->second.second );
values_map.insert( std::make_pair( truth_table_cube_to_number( in ), truth_table_cube_to_number( out ) ) );
}
// Set of cycles
std::vector<std::vector<unsigned> > cycles;
while ( !values_map.empty() )
{
unsigned start_value = values_map.begin()->first; // first key in values_map
std::vector<unsigned> cycle;
unsigned target = start_value;
do
{
cycle += target;
unsigned old_target = target;
target = values_map[target];
values_map.erase( old_target ); // erase this entry
} while ( target != start_value );
cycles += cycle;
}
for ( auto& cycle : cycles )
{
unsigned max_distance = 0u;
unsigned max_index = 0u;
for ( unsigned i = 0u; i < cycle.size(); ++i )
{
unsigned first = cycle.at(i);
unsigned second = cycle.at( (i + 1u) % cycle.size() );
unsigned distance = hamming_distance( first, second );
if ( distance > max_distance )
{
max_distance = distance;
max_index = i;
}
}
std::vector<unsigned> tmp;
std::copy( cycle.begin() + ( max_index + 1u ), cycle.end(), std::back_inserter( tmp ) );
std::copy( cycle.begin(), cycle.begin() + ( max_index + 1u ), std::back_inserter( tmp ) );
std::copy( tmp.begin(), tmp.end(), cycle.begin() );
std::reverse( cycle.begin(), cycle.end() );
}
// TODO create transpositions function
for ( auto& cycle : cycles )
{
for ( unsigned i = 0u; i < cycle.size() - 1; ++i )
{
circuit transposition_circ( spec.num_inputs() );
unsigned first = cycle.at(i);
unsigned second = cycle.at( (i + 1) % cycle.size() );
boost::dynamic_bitset<> first_bits( spec.num_inputs(), first );
boost::dynamic_bitset<> second_bits( spec.num_inputs(), second );
transposition_to_circuit( transposition_circ, first_bits, second_bits );
append_circuit( circ, transposition_circ);
}
}
return true;
}
int main(int argc, char *argv[])
{
if (argc != 2){
std::cout << "Usage: ch6 <input_file>" << std::endl;
return -1;
}
string filename {argv[1]};
string decoded, line;
std::ifstream input {filename};
int KEYSIZE {40};
std::multimap<double, int> keysize_mapping;
if (input.is_open()){
while (std::getline(input, line)){
decoded += base64_decrypt(line);
}
}
for (int i = 2; i < KEYSIZE; i++){
string str1 {decoded.substr(0, i)};
string str2 {decoded.substr(i, i)};
assert(str1.size() == str2.size());
int distance {hamming_distance(str1, str2)};
double score = (distance / (double) i);
keysize_mapping.insert(std::pair<double, int>(score, i));
}
std::multimap<double, int>::iterator it {keysize_mapping.begin()};
std::vector<int> better_keysizes;
for (int i = 0; it != keysize_mapping.end(); it++, i++){
if (i == 8){
break;
}
better_keysizes.push_back(it->second);
}
for(int keysize : better_keysizes){
int blocks = ceil(decoded.size() / keysize);
std::vector<string> transposed;
printf("keysize: %d\n", keysize);
for(int i = 0; i < keysize; i++){
transposed.push_back(string {});
for(int block = 0; block < blocks; block++){
int index = (block * keysize) + i;
if (index < decoded.size()){
char hex[2];
sprintf(hex, "%02X", decoded[index]);
transposed[i] += hex;
}else{
transposed[i] += '\0';
}
}
}
for(string str : transposed){
std::multimap<int, struct decoded_string> ranking = probe_keys(str);
std::multimap<int, struct decoded_string>::reverse_iterator rit;
int limit = 0;
for(rit = ranking.rbegin(); rit != ranking.rend(); rit++, limit++){
char key = rit->second.key;
std::cout << key << " ";
if (limit == 2)
break;
}
std::cout << std::endl;
}
std::cout << std::endl;
}
return 0;
}
