Short answer: No, time() is not a good salt. Long answer: copied from my answer to Salt Generation and open source software What is a salt? A salt is a random set of bytes of a fixed length that is added to the input of a hash algorithm. Why is salting (or seeding) a hash … Read more
It being the “best” is argumentative. It being “good”, or even “very good”, at least superficially, is easy. seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2); We’ll presume seed is a previous result of hasher or this algorithm. ^= means that the bits on the left and bits on the right all change the … Read more
This is what I’m using for SHA1: #import <CommonCrypto/CommonDigest.h> + (NSData *)sha1:(NSData *)data { unsigned char hash[CC_SHA1_DIGEST_LENGTH]; if ( CC_SHA1([data bytes], [data length], hash) ) { NSData *sha1 = [NSData dataWithBytes:hash length:CC_SHA1_DIGEST_LENGTH]; return sha1; } return nil; } Replace CC_SHA1 with CC_SHA256 (or whichever you need), as well as CC_SHA1_DIGEST_LENGTH with CC_SHA256_DIGEST_LENGTH.
Hash does not have dot-syntax for it’s keys. OpenStruct does: require ‘ostruct’ hash = {:name => ‘John’} os = OpenStruct.new(hash) p os.name #=> “John” NOTE: Does not work with nested hashes.
First you shoud maybe read this article. When you use lists and you are looking for a special item you normally have to iterate over the complete list. This is very expensive when you have large lists. A hashtable can be a lot faster, under best circumstances you will get the item you are looking … Read more
MD5 is a one-way-hash algorithm. One-way-hash algorithms are often used in cryptography as they have the property (per design) that it’s hard to find the input that produced a specific hash value. Specifically it’s hard to make two different inputs that give the same one-way-hash. They are often used as a way to show that … Read more
Use md5(serialize()) instead of print_r(). print_r()‘s purpose is primarily as a debugging function and is formatted for plain text display, whereas serialize() encodes an array or object representation as a compact text string for persistance in database or session storage (or any other persistance mechanism).
hash = {“apple” => “banana”, “coconut” => “domino”} Hash[hash.map{ |k, v| [k.to_sym, v] }] #=> {:apple=>”banana”, :coconut=>”domino”} @mu is too short: Didn’t see word “recursive”, but if you insist (along with protection against non-existent to_sym, just want to remind that in Ruby 1.8 1.to_sym == nil, so playing with some key types can be misleading): … Read more
Okay, now that you specified the actually meaning of ‘threadsafe’, here are two potential implementations. The following code will run forever in MRI and JRuby. The lockless implementation follows an eventual consistency model where each thread uses it’s own view of the hash if the master is in flux. There is a little trickery required … Read more
Here is a good explanation about hashing. For example you want to store the string “Rachel” you apply a hash function to that string to get a memory location. myHashFunction(key: “Rachel” value: “Rachel”) –> 10. The function may return 10 for the input “Rachel” so assuming you have an array of size 100 you store … Read more