dolores-shacontest 0.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Dolores Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= shacontest
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2009 Dolores Labs. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,101 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "shacontest"
+    gem.summary = %Q{Generate SHA keys and win an iPhone}
+    gem.email = "brian@doloreslabs.com"
+    gem.homepage = "http://github.com/dolores/shacontest"
+    gem.authors = ["Brian P O'Rourke"]
+    gem.extensions = ["ext/dl_contest/extconf.rb"]
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+  puts "This is required only at buildtime."
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => [:compile, :spec]
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "shacontest #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+require 'rake/clean'
+extension = 'dl_contest'
+ext = "ext/#{extension}"
+BIN = "*.{bundle,jar,so,o,obj,pdb,lib,def,exp,class}"
+CLEAN.include ["#{ext}/#{BIN}", "lib/**/#{BIN}", "#{ext}/Makefile",
+                '**/.*.sw?', '*.gem', '.config', 'pkg']
+
+
+ext_so = "#{ext}/#{extension}.#{Config::CONFIG['DLEXT']}"
+ext_files = FileList[
+  "#{ext}/*.c",
+  "#{ext}/*.h",
+  "#{ext}/extconf.rb",
+  "#{ext}/Makefile",
+  "lib"
+]
+ 
+desc "Builds the #{ext} extension"
+task extension.to_sym => [ "#{ext}/Makefile", ext_so ]
+
+file "#{ext}/Makefile" => ["#{ext}/extconf.rb"] do
+  Dir.chdir(ext) do ruby "extconf.rb" end
+end
+   
+file ext_so => ext_files do
+  Dir.chdir(ext) do
+    sh(RUBY_PLATFORM =~ /mswin/ ? 'nmake' : 'make')
+  end
+  cp ext_so, "lib"
+end
+
+desc "Compiles the ruby extension"
+task :compile => :dl_contest do
+  if Dir.glob(File.join('lib', 'dl_contest.*')).length == 0
+    STDERR.puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+    STDERR.puts "Compilation failed. The build was not"
+    STDERR.puts "properly configured to run on this system."
+    STDERR.puts "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+    exit(1)
+  end
+end
+
+desc 'Benchmarks performance'
+task :benchmark => :compile do
+  $: << 'lib'
+  require 'dl_contest'
+  require 'benchmark'
+   
+  Benchmark.bm do |x|
+    x.report { Contest.new.benchmark }
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/bin/shacontest

@@ -0,0 +1,4 @@
+#! /usr/bin/env ruby
+require 'shacontest'
+
+Shacontest::CLInterface.new.main

data/ext/dl_contest/dl_contest.c

@@ -0,0 +1,43 @@
+#include "ruby.h"
+
+static VALUE c_test(VALUE self)
+{
+    return test_suite() ? Qtrue : Qfalse;
+}
+
+static VALUE c_benchmark(VALUE self)
+{
+    return benchmark() ? Qtrue : Qfalse;
+}
+
+static VALUE c_best_capitalization(VALUE self, VALUE target, VALUE my_string, VALUE start, VALUE end, VALUE output_freq)
+{
+    char *p_target;
+    VALUE str_target = StringValue(target);
+    p_target = RSTRING(str_target)->ptr;
+
+    char *p_my_string;
+    VALUE str_my_string = StringValue(my_string);
+    p_my_string = RSTRING(str_my_string)->ptr;
+
+    char words[140];
+    // this is only safe since we're unicode-free on the rb side
+    strcpy(words, p_my_string);
+
+    long long int l_start =        NUM2LL(start);
+    long long int l_end =          NUM2LL(end);
+    long long int l_output_freq =  NUM2LL(output_freq);
+
+    find_best_capitalization(p_target, words, l_start, l_end, l_output_freq);
+
+    return rb_str_new2( words );
+}
+
+VALUE cContest;
+
+void Init_dl_contest() {
+    cContest = rb_define_class("Contest", rb_cObject);
+    rb_define_method(cContest, "test", c_test, 0);
+    rb_define_method(cContest, "benchmark", c_benchmark, 0);
+    rb_define_method(cContest, "best_capitalization", c_best_capitalization, 5);
+}

data/ext/dl_contest/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS = "-O3 -fno-common -arch ppc -arch i386 -pipe"
+create_makefile 'dl_contest'

data/ext/dl_contest/os_types.h

@@ -0,0 +1,30 @@
+/*
+    jbig2dec
+    
+    Copyright (c) 2002 artofcode LLC.
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+        
+    $Id: os_types.h,v 1.1 2002/07/20 17:23:15 giles Exp $
+*/
+
+/*
+   indirection layer for build and platform-specific definitions
+
+   in general, this header should insure that the stdint types are
+   available, and that any optional compile flags are defined if
+   the build system doesn't pass them directly.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config_types.h"
+#elif defined(_WIN32)
+#include "config_win32.h"
+#endif
+
+#if defined(HAVE_STDINT_H) || defined(__MACOS__)
+#include <stdint.h>
+#endif

data/ext/dl_contest/sha1b.c

@@ -0,0 +1,585 @@
+#ifndef _SHA1_H   
+#define _SHA1_H   
+#include <string.h>  
+
+#define uint8  unsigned char   
+#define uint32 unsigned long int   
+#define SHA1_DIGEST_SIZE_32 5
+/* self test */
+#include <stdlib.h>
+#include <limits.h>
+#include <stdio.h>
+#include <errno.h>
+
+struct sha1_context   
+{   
+    uint32 total[2];   
+    uint32 state[5];   
+    uint8 buffer[64];   
+};   
+   
+void sha1_starts( struct sha1_context *ctx );   
+void sha1_update( struct sha1_context *ctx, uint8 *input, uint32 length );   
+void sha1_finish( struct sha1_context *ctx, uint8 digest[20] );   
+   
+#endif /* sha1.h */   
+   
+   
+   
+/*  
+ * FIPS 180-1 compliant SHA-1 implementation,  
+ * by Christophe Devine <devine@cr0.net>;  
+ * this program is licensed under the GPL.  
+ */   
+   
+ 
+   
+#define GET_UINT32(n,b,i)                                       \
+{                                                               \
+    (n) = (uint32) ((uint8 *) b)[(i)+3]                         \
+      | (((uint32) ((uint8 *) b)[(i)+2]) <<  8)                 \
+      | (((uint32) ((uint8 *) b)[(i)+1]) << 16)                 \
+      | (((uint32) ((uint8 *) b)[(i)]  ) << 24);                \
+}
+
+#define PUT_UINT32(n,b,i)                                       \
+{                                                               \
+    (((uint8 *) b)[(i)+3]) = (uint8) (((n)      ) & 0xFF);      \
+    (((uint8 *) b)[(i)+2]) = (uint8) (((n) >>  8) & 0xFF);      \
+    (((uint8 *) b)[(i)+1]) = (uint8) (((n) >> 16) & 0xFF);      \
+    (((uint8 *) b)[(i)]  ) = (uint8) (((n) >> 24) & 0xFF);      \
+}
+
+void sha1_starts( struct sha1_context *ctx )   
+{   
+    ctx->total[0] = 0;   
+    ctx->total[1] = 0;   
+    ctx->state[0] = 0x67452301;   
+    ctx->state[1] = 0xEFCDAB89;   
+    ctx->state[2] = 0x98BADCFE;   
+    ctx->state[3] = 0x10325476;   
+    ctx->state[4] = 0xC3D2E1F0;   
+}   
+   
+void sha1_process( struct sha1_context *ctx, uint8 data[64] )   
+{   
+    uint32 temp, A, B, C, D, E, W[16];   
+   
+    GET_UINT32( W[0],  data,  0 );   
+    GET_UINT32( W[1],  data,  4 );   
+    GET_UINT32( W[2],  data,  8 );   
+    GET_UINT32( W[3],  data, 12 );   
+    GET_UINT32( W[4],  data, 16 );   
+    GET_UINT32( W[5],  data, 20 );   
+    GET_UINT32( W[6],  data, 24 );   
+    GET_UINT32( W[7],  data, 28 );   
+    GET_UINT32( W[8],  data, 32 );   
+    GET_UINT32( W[9],  data, 36 );   
+    GET_UINT32( W[10], data, 40 );   
+    GET_UINT32( W[11], data, 44 );   
+    GET_UINT32( W[12], data, 48 );   
+    GET_UINT32( W[13], data, 52 );   
+    GET_UINT32( W[14], data, 56 );   
+    GET_UINT32( W[15], data, 60 );   
+   
+#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
+   
+#define R(t)                                            \
+(                                                       \
+    temp = W[(t -  3) & 0x0F] ^ W[(t - 8) & 0x0F] ^     \
+           W[(t - 14) & 0x0F] ^ W[ t      & 0x0F],      \
+    ( W[t & 0x0F] = S(temp,1) )                         \
+)
+
+#define P(a,b,c,d,e,x)                                  \
+{                                                       \
+    e += S(a,5) + F(b,c,d) + K + x; b = S(b,30);        \
+}
+   
+    A = ctx->state[0];   
+    B = ctx->state[1];   
+    C = ctx->state[2];   
+    D = ctx->state[3];   
+    E = ctx->state[4];   
+   
+#define F(x,y,z) (z ^ (x & (y ^ z)))   
+#define K 0x5A827999   
+   
+    P( A, B, C, D, E, W[0]  );   
+    P( E, A, B, C, D, W[1]  );   
+    P( D, E, A, B, C, W[2]  );   
+    P( C, D, E, A, B, W[3]  );   
+    P( B, C, D, E, A, W[4]  );   
+    P( A, B, C, D, E, W[5]  );   
+    P( E, A, B, C, D, W[6]  );   
+    P( D, E, A, B, C, W[7]  );   
+    P( C, D, E, A, B, W[8]  );   
+    P( B, C, D, E, A, W[9]  );   
+    P( A, B, C, D, E, W[10] );   
+    P( E, A, B, C, D, W[11] );   
+    P( D, E, A, B, C, W[12] );   
+    P( C, D, E, A, B, W[13] );   
+    P( B, C, D, E, A, W[14] );   
+    P( A, B, C, D, E, W[15] );   
+    P( E, A, B, C, D, R(16) );   
+    P( D, E, A, B, C, R(17) );   
+    P( C, D, E, A, B, R(18) );   
+    P( B, C, D, E, A, R(19) );   
+   
+#undef K   
+#undef F   
+   
+#define F(x,y,z) (x ^ y ^ z)   
+#define K 0x6ED9EBA1   
+   
+    P( A, B, C, D, E, R(20) );   
+    P( E, A, B, C, D, R(21) );   
+    P( D, E, A, B, C, R(22) );   
+    P( C, D, E, A, B, R(23) );   
+    P( B, C, D, E, A, R(24) );   
+    P( A, B, C, D, E, R(25) );   
+    P( E, A, B, C, D, R(26) );   
+    P( D, E, A, B, C, R(27) );   
+    P( C, D, E, A, B, R(28) );   
+    P( B, C, D, E, A, R(29) );   
+    P( A, B, C, D, E, R(30) );   
+    P( E, A, B, C, D, R(31) );   
+    P( D, E, A, B, C, R(32) );   
+    P( C, D, E, A, B, R(33) );   
+    P( B, C, D, E, A, R(34) );   
+    P( A, B, C, D, E, R(35) );   
+    P( E, A, B, C, D, R(36) );   
+    P( D, E, A, B, C, R(37) );   
+    P( C, D, E, A, B, R(38) );   
+    P( B, C, D, E, A, R(39) );   
+   
+#undef K   
+#undef F   
+   
+#define F(x,y,z) ((x & y) | (z & (x | y)))   
+#define K 0x8F1BBCDC   
+   
+    P( A, B, C, D, E, R(40) );   
+    P( E, A, B, C, D, R(41) );   
+    P( D, E, A, B, C, R(42) );   
+    P( C, D, E, A, B, R(43) );   
+    P( B, C, D, E, A, R(44) );   
+    P( A, B, C, D, E, R(45) );   
+    P( E, A, B, C, D, R(46) );   
+    P( D, E, A, B, C, R(47) );   
+    P( C, D, E, A, B, R(48) );   
+    P( B, C, D, E, A, R(49) );   
+    P( A, B, C, D, E, R(50) );   
+    P( E, A, B, C, D, R(51) );   
+    P( D, E, A, B, C, R(52) );   
+    P( C, D, E, A, B, R(53) );   
+    P( B, C, D, E, A, R(54) );   
+    P( A, B, C, D, E, R(55) );   
+    P( E, A, B, C, D, R(56) );   
+    P( D, E, A, B, C, R(57) );   
+    P( C, D, E, A, B, R(58) );   
+    P( B, C, D, E, A, R(59) );   
+   
+#undef K   
+#undef F   
+   
+#define F(x,y,z) (x ^ y ^ z)   
+#define K 0xCA62C1D6   
+   
+    P( A, B, C, D, E, R(60) );   
+    P( E, A, B, C, D, R(61) );   
+    P( D, E, A, B, C, R(62) );   
+    P( C, D, E, A, B, R(63) );   
+    P( B, C, D, E, A, R(64) );   
+    P( A, B, C, D, E, R(65) );   
+    P( E, A, B, C, D, R(66) );   
+    P( D, E, A, B, C, R(67) );   
+    P( C, D, E, A, B, R(68) );   
+    P( B, C, D, E, A, R(69) );   
+    P( A, B, C, D, E, R(70) );   
+    P( E, A, B, C, D, R(71) );   
+    P( D, E, A, B, C, R(72) );   
+    P( C, D, E, A, B, R(73) );   
+    P( B, C, D, E, A, R(74) );   
+    P( A, B, C, D, E, R(75) );   
+    P( E, A, B, C, D, R(76) );   
+    P( D, E, A, B, C, R(77) );   
+    P( C, D, E, A, B, R(78) );   
+    P( B, C, D, E, A, R(79) );   
+   
+#undef K   
+#undef F   
+   
+    ctx->state[0] += A;   
+    ctx->state[1] += B;   
+    ctx->state[2] += C;   
+    ctx->state[3] += D;   
+    ctx->state[4] += E;   
+}   
+   
+void sha1_update( struct sha1_context *ctx, uint8 *input, uint32 length )   
+{   
+    uint32 left, fill;   
+   
+    if( ! length ) return;   
+   
+    left = ( ctx->total[0] >> 3 ) & 0x3F;   
+    fill = 64 - left;   
+   
+    ctx->total[0] += length <<  3;   
+    ctx->total[1] += length >> 29;   
+   
+    ctx->total[0] &= 0xFFFFFFFF;   
+    ctx->total[1] += ctx->total[0] < length << 3;   
+   
+    if( left && length >= fill )   
+    {   
+        memcpy( (void *) (ctx->buffer + left), (void *) input, fill );   
+        sha1_process( ctx, ctx->buffer );   
+        length -= fill;   
+        input  += fill;   
+        left = 0;   
+    }   
+   
+    while( length >= 64 )   
+    {   
+        sha1_process( ctx, input );   
+        length -= 64;   
+        input  += 64;   
+    }   
+   
+    if( length )   
+    {   
+        memcpy( (void *) (ctx->buffer + left), (void *) input, length );   
+    }   
+}   
+   
+static uint8 sha1_padding[64] =   
+{   
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0   
+};   
+
+static uint8 hamm_cache[256];
+   
+void sha1_finish( struct sha1_context *ctx, uint8 digest[16] )   
+{   
+    uint32 last, padn;   
+    uint8 msglen[8];   
+   
+    PUT_UINT32( ctx->total[1], msglen, 0 );   
+    PUT_UINT32( ctx->total[0], msglen, 4 );   
+   
+    last = ( ctx->total[0] >> 3 ) & 0x3F;   
+    padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );   
+   
+    sha1_update( ctx, sha1_padding, padn );   
+    sha1_update( ctx, msglen, 8 );   
+   
+    PUT_UINT32( ctx->state[0], digest,  0 );   
+    PUT_UINT32( ctx->state[1], digest,  4 );   
+    PUT_UINT32( ctx->state[2], digest,  8 );   
+    PUT_UINT32( ctx->state[3], digest, 12 );   
+    PUT_UINT32( ctx->state[4], digest, 16 );   
+}   
+   
+   
+#include <stdlib.h>   
+#include <stdio.h>   
+   
+#include <stdint.h>
+int hamming_dist(const uint32_t digest1[SHA1_DIGEST_SIZE_32], const uint32_t digest2[SHA1_DIGEST_SIZE_32]) {
+	
+	int i,j;
+	int total_dist = 0;
+    for (i = 0; i < SHA1_DIGEST_SIZE_32; i++) {
+		uint32_t x = digest1[i];
+		uint32_t y = digest2[i];
+	  unsigned int dist = 0, val = x ^ y;
+
+	  while(val)
+	  {
+	    ++dist; 
+	    val &= val - 1;
+	  }
+
+	  total_dist += dist;
+	}
+	return 0;//total_dist;
+}
+
+
+
+int build_hamm_cache() {
+	int i;
+	for(i=0; i<256; i++) {
+		int val = i;
+		int dist = 0;
+		while(val)
+	  	{
+	    	++dist; 
+	    	val &= val - 1;
+	  	}
+		hamm_cache[i] = dist;
+
+	}
+
+}
+
+int hamming_dist_cached(const uint32_t digest1[SHA1_DIGEST_SIZE_32], const uint32_t digest2[SHA1_DIGEST_SIZE_32] ) {
+
+	int i,j;
+	int total_dist = 0;
+    for (i = 0; i < SHA1_DIGEST_SIZE_32; i++) {
+		uint32_t x = digest1[i];
+		uint32_t y = digest2[i];
+		uint32_t val = (x ^ y);
+		uint32_t* val_ptr = &val;
+
+		int d0 = hamm_cache[(int)(((uint8_t*)val_ptr)[0])];
+		int d1 = hamm_cache[(int)(((uint8_t*)val_ptr)[1])];
+		int d2 = hamm_cache[(int)(((uint8_t*)val_ptr)[2])];
+		int d3 = hamm_cache[(int)(((uint8_t*)val_ptr)[3])];
+		
+
+	  total_dist += d0 + d1 +d2 + d3;
+	}
+
+	return total_dist;
+}
+
+
+
+int test_hamm_cache() {
+	uint32_t d1[5];
+	uint32_t d2[5];
+	d1[0] = 0; d1[1] = 0; d1[2] = 0; d1[3] = 0; d1[4] = 0;
+	d2[0] = 0; d2[1] = 0; d2[2] = 0; d2[3] = 0; d2[4] = 0;
+	
+	int a = hamming_dist_cached(d1, d2);
+	printf("Hamm Cache Test: %i", a);
+}
+
+
+int find_best_capitalization(const char* target, char* words, uint64_t start, uint64_t end, uint64_t output_freq) {
+	build_hamm_cache();
+	
+	struct sha1_context ctx;  
+    uint8_t digestR[20];
+	char wordsR[10];
+	sha1_starts( &ctx );
+	sha1_update( &ctx, (uint8 *)target, strlen(target) ); 
+	sha1_finish( &ctx, digestR );   
+    
+    //SHA1_Update(&context, (uint8_t*)target, strlen(target));
+    //SHA1_Final(&context, digestR);
+	int i;
+	
+	printf("Target Sentence: %s\n", target);
+	printf("My Sentence: %s\n", words);
+	printf("Start %llu\n", start);
+	printf("End %llu\n\n", end);
+	
+	
+	int l = strlen(words);
+	uint64_t p = 0; // iterates over all possible capitalizations
+	
+	const char lower_case_mask = 32;
+	const char upper_case_mask = 255 - 32;
+	
+	uint8_t digest[20];
+	char output[80];
+	int min = 100000;
+	char argmin[140];	
+	
+	   // end = 1LL << 60;
+
+	//SHA1_Init(&context);
+    //SHA1_Update(&context, (uint8_t*)words, strlen(words));
+    //SHA1_Final(&context, digest);
+
+	int max_bit = 1;
+	
+	p = start;
+	
+	int z;
+	for (z=0;z<63;z++) {
+		if (p & (1LL << z)) {
+			max_bit = z;
+		}
+	}
+	
+	sha1_starts( &ctx );
+	sha1_update( &ctx, (uint8 *)words, strlen(words) ); 
+	sha1_finish( &ctx, digest );
+	
+	for (p; p < end; p++) {
+		//printf("%i\n", max_bit);
+		
+		if (p & (1LL << max_bit)) {
+			max_bit++;
+		}
+				
+		int offset = 0;
+		int i = 0;
+		for (i=0; i<=l; i++) {
+			//printf("%i", words[i]);
+			if (offset > max_bit) {
+				break;
+			}
+			
+			if (words[i] == 0) { // end of string
+				break;
+			}
+			
+			if (words[i] & 64) { // it's an ascii character
+
+				uint64_t mask = 1LL << offset;
+				if (p & mask) {// should be uppercase!
+					words[i] &= upper_case_mask;
+				} else { // should be lowercase!
+					words[i] |= lower_case_mask;
+				//if (word[i] )
+				}
+				offset++;
+			}
+		}
+		//printf("%s\n", words);
+		
+		//SHA1_Init(&context);
+    	//SHA1_Update(&context, (uint8_t*)words, strlen(words));
+    	//SHA1_Final(&context, digest);
+		
+		sha1_starts( &ctx );
+		sha1_update( &ctx, (uint8 *)words, strlen(words) ); 
+		sha1_finish( &ctx, digest );
+		
+
+		int h = hamming_dist_cached((uint32_t*)digest, (uint32_t*)digestR);
+		if (h<min) {
+			min = h;
+			strcpy(argmin, words);
+		}
+		
+		if (p % output_freq == 0) {
+			printf("Offset: %lld Word: %s Score: %i\n", p, argmin, min);
+		}
+	}
+	printf("Finishing...\n\nWord: %s Score: %i\n", argmin, min);
+	return min;
+}
+
+int test_suite() {
+	char t1[140];
+	strcpy(t1, "test test test test test abcdefghijklmnopqrstuvwxyz");
+	int test1 = find_best_capitalization("test", t1, 0, 1000, 10000000);
+	printf("\n\n***TEST 1 (basic test)                  Value: %i Should be 63\n\n\n", test1);
+
+	char t2[140];
+	strcpy(t2, "test test test test test abcdefghijklmnopqrstuvwxyz");
+	int test2 = find_best_capitalization("test", t2, (1LL<<33), (1LL<<33)+100, 10000000);
+	printf("\n\n***TEST 2 (64-bit compatibility test)   Value: %i Should be 62\n\n\n", test2);
+	
+	char t3[140];
+	strcpy(t3, "a12 b34 c56 d78 efgh");
+	int test3 = find_best_capitalization("test", t3, 0, 1000, 10000000);
+	printf("\n\n***TEST 3 (weird string input test)     Value: %i Should be 60\n\n\n", test3);	
+}
+
+
+
+
+
+
+int main(int argc, char** argv)
+{
+	
+        long long int output_freq;
+        char *endptr;
+        //test_best_hamming_dist();                                                                                            
+        char words[140];
+        if (argc == 6) {
+                strcpy(words, argv[2]);
+                //fprintf(stderr, "Here");
+                errno = 0;
+                long long int start = strtoll(argv[3], &endptr, 10);
+                //fprintf(stderr, "%i", errno);
+                //fprintf(stderr, "L\n\n%s\nVAL: %llu\n\n %lld %s\n\n", argv[3], start, endptr);
+                long long int end = strtoll(argv[4], &endptr, 10);
+                //fprintf(stderr, "O");
+                output_freq = strtoll(argv[5], &endptr, 10);
+
+                //uint64_t start = 0;                                                                                          
+                //uint64_t end = 1LL << 50;                                                                                    
+                //fprintf(stderr,"ere\n");
+		find_best_capitalization(argv[1], words, start, end, output_freq );
+    } else if (argc == 1) {
+		//test_hamm_cache();
+		test_suite();
+    } else {
+        printf("Usage: sha2k <target-sentence> <modifiable-sentence> <start> <end> <output-freq>\n");
+    }
+    return 0;
+
+        //digest_to_hex(digest, output);                                                                                       
+        //fprintf(stderr,"\t%s returned\n", output);                                                                           
+}
+  
+   /*
+int main( void )   
+{   
+    int i, j;   
+    char output[41], *buf;   
+    struct sha1_context ctx;   
+    unsigned char sha1sum[20];   
+   
+    for( i = 0; i < 3; i++ )   
+    {   
+        sha1_starts( &ctx );   
+   
+        if( i < 2 )   
+        {   
+            sha1_update( &ctx, (uint8 *) msg[i], strlen( msg[i] ) );   
+        }   
+        else   
+        {   
+            if( ! ( buf = (char *) malloc( 1000 ) ) )   
+            {   
+                perror( "malloc" );   
+                return( 1 );   
+            }   
+   
+            memset( buf, 'a', 1000 );   
+   
+            for( j = 0; j < 1000; j++ )   
+            {   
+                sha1_update( &ctx, (uint8 *) buf, 1000 );   
+            }   
+   
+            free( buf );   
+        }   
+   
+        sha1_finish( &ctx, sha1sum );   
+   
+        for( j = 0; j < 20; j++ )   
+        {   
+            sprintf( output + j * 2, "%02x", sha1sum[j] );   
+        }   
+   
+        printf( "test %d ", i + 1 );   
+   
+        if( ! memcmp( output, val[i], 40 ) )   
+        {   
+            printf( "passed\n" );   
+        }   
+        else   
+        {   
+            printf( "failed\n" );   
+            return( 1 );   
+        }   
+    }   
+   
+    return( 0 );   
+}*/

data/lib/shacontest.rb

@@ -0,0 +1,137 @@
+require 'cgi'
+require 'dl_contest'
+require 'fileutils'
+require 'net/http'
+require 'optparse'
+require 'uri'
+require 'yaml'
+
+CONFIGS = { 'email' => 'email address' }
+module Shacontest
+  HOME = 'http://shacontest.doloreslabs.com/'
+  SENT = 'six six six six six six six six six six six six'
+  REF = 'I am not a big believer in fortune telling'
+
+  BLOCK_SIZE  = 50000000
+  REPORT_FREQ = 1000000
+
+  class Competitor
+    def initialize(config)
+      @my_id = rando
+      @email = config['email']
+      puts "Hi, #{@email}. Your temporary worker ID is '#{@my_id}'"
+    end
+
+    def run
+      c = Contest.new
+      start = 1
+      finish = start + BLOCK_SIZE
+
+      while true
+        @best_yet = c.best_capitalization REF, "#{SENT}#{@my_id}", start, finish, REPORT_FREQ
+        phone_home
+        start = finish + 1
+        finish = start + BLOCK_SIZE
+      end
+    end
+    
+    def phone_home
+      url = URI.parse('http://shacontest.doloreslabs.com/')
+      res = Net::HTTP.start(url.host, url.port) {|http|
+        http.request_get("/submit/#{CGI::escape(@email)}/#{CGI::escape(@best_yet)}")
+      }
+    end
+
+    def rando
+      chars = [('a'..'z')].map{|i| i.to_a}.flatten;  
+      string  =  (0..5).map{ chars[rand(chars.length)] }.join;
+    end
+  end
+
+  class Config
+    CONFIG_DIR = "#{ENV['HOME']}/.dlabs"
+    CONFIG_FILE = "#{CONFIG_DIR}/config"
+
+    def initialize
+      reset
+      FileUtils.mkdir_p CONFIG_DIR
+      if File.exists?(CONFIG_FILE)
+        @config = File.open(CONFIG_FILE) {|yf| YAML.load(yf)}
+      end
+    end
+   
+    # Accessor for all configuration data
+    def [](index)
+      @config[index]
+    end
+
+    def reset
+      @config = Hash.new
+    end
+
+    def configure
+      STDOUT.puts "Dolores Labs Crowd Computing Challenge"
+  
+      CONFIGS.each do |k,v|
+        puts "Enter your #{v}"
+  
+        @config[k] = gets.strip
+      end
+  
+      File.open(CONFIG_FILE, 'w') {|f| YAML.dump(@config, f)}
+      puts "Configuration complete."
+    end
+
+    def configured?
+      configured = true
+      CONFIGS.each_key do |k|
+        configured = false if @config[k].nil?
+      end
+  
+      configured
+    end
+  end
+
+  class CLInterface
+    def initialize
+      @config = Config.new
+    end
+
+    def main
+      interactive = true
+  
+      opts = OptionParser.new do |opts|
+        opts.banner = <<-EOF
+          Dolores Labs Crowd Computing Challenge
+
+          Usage #{$0} [options]
+
+        EOF
+  
+        opts.on('-h', '--help', 'Show this usage information') do
+          puts opts
+          return 0
+        end
+        opts.on('-i', '--interactive', 'Force interactive setup.') do
+          @config.reset
+        end
+      end
+  
+      begin
+        opts.parse!(ARGV)
+      rescue OptionParser::ParseError => e
+        STDERR.puts e.message, $/
+        STDERR.puts opts
+        return 1
+      end
+  
+      if (interactive)
+        # Check that we have all the user input needed
+        @config.configure unless @config.configured?
+  
+        # Kick off the update
+        Competitor.new(@config).run
+      end
+    end
+  end
+end

data/shacontest.gemspec

@@ -0,0 +1,54 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{shacontest}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brian P O'Rourke"]
+  s.date = %q{2009-07-19}
+  s.default_executable = %q{shacontest}
+  s.email = %q{brian@doloreslabs.com}
+  s.executables = ["shacontest"]
+  s.extensions = ["ext/dl_contest/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/shacontest",
+     "ext/dl_contest/dl_contest.c",
+     "ext/dl_contest/extconf.rb",
+     "ext/dl_contest/os_types.h",
+     "ext/dl_contest/sha1b.c",
+     "lib/shacontest.rb",
+     "shacontest.gemspec",
+     "spec/shacontest_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/dolores/shacontest}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Generate SHA keys and win an iPhone}
+  s.test_files = [
+    "spec/shacontest_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/shacontest_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'benchmark'
+
+describe Shacontest do
+  it "exists" do
+    Shacontest.nil?.should == false
+  end
+end
+
+describe Contest do
+  it 'has an internal test suite that runs correctly' do
+    Contest.new.test.should == true
+  end
+
+  it 'finds best capitalization' do
+    c = Contest.new
+    string = c.best_capitalization 'This is a candidate sentence', 'my case will be manipulated to get better output', 1, 5000000, 200000
+    string.should == 'MY CASE wiLL bE maNipuLAteD to get better output'
+  end
+
+  it 'has no egregious memory leaks' do
+    1.times do |i|
+    #1000000.times do |i|
+      c = Contest.new
+      c.best_capitalization 'This is a candidate sentence', 'here is a set of characters to manipulate', 1, 100, 1000
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'shacontest'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: dolores-shacontest
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Brian P O'Rourke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-19 00:00:00 -07:00
+default_executable: shacontest
+dependencies: []
+
+description: 
+email: brian@doloreslabs.com
+executables: 
+- shacontest
+extensions: 
+- ext/dl_contest/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/shacontest
+- ext/dl_contest/dl_contest.c
+- ext/dl_contest/extconf.rb
+- ext/dl_contest/os_types.h
+- ext/dl_contest/sha1b.c
+- lib/shacontest.rb
+- shacontest.gemspec
+- spec/shacontest_spec.rb
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/dolores/shacontest
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Generate SHA keys and win an iPhone
+test_files: 
+- spec/shacontest_spec.rb
+- spec/spec_helper.rb