lib/MogileFS/Checksum.pm

   1 package MogileFS::Checksum;
   2 use strict;
   3 use warnings;
   4 use overload '""' => \&as_string;
   5
   6 my %TYPE = (
   7     "MD5"     => { type => 1, bytelen => 128 / 8 },
   8     "SHA-1"   => { type => 2, bytelen => 160 / 8 },
   9
  10 # see POD for rationale below
  11 #   "SHA-224" => { type => 3, bytelen => 224 / 8 },
  12 #   "SHA-256" => { type => 4, bytelen => 256 / 8 },
  13 #   "SHA-384" => { type => 5, bytelen => 384 / 8 },
  14 #   "SHA-512" => { type => 6, bytelen => 512 / 8 },
  15 );
  16
  17 our %NAME2TYPE = map { $_ => $TYPE{$_}->{type} } keys(%TYPE);
  18 our %TYPE2NAME = map { $NAME2TYPE{$_} => $_ } keys(%NAME2TYPE);
  19
  20 sub valid_alg {
  21     my ($class, $alg) = @_;
  22
  23     defined($alg) && defined($TYPE{$alg});
  24 }
  25
  26 sub new {
  27     my ($class, $row) = @_;
  28     my $self = bless {
  29         fidid => $row->{fid},
  30         checksum => $row->{checksum},
  31         hashtype => $row->{hashtype}
  32     }, $class;
  33
  34     return $self;
  35 }
  36
  37 # $string = "MD5:d41d8cd98f00b204e9800998ecf8427e"
  38 sub from_string {
  39     my ($class, $fidid, $string) = @_;
  40     $string =~ /\A([\w-]+):([a-fA-F0-9]{32,128})\z/ or
  41         die "invalid checksum string";
  42     my $hashname = $1;
  43     my $hexdigest = $2;
  44     my $ref = $TYPE{$hashname} or
  45         die "invalid checksum name ($hashname) from $string";
  46     my $checksum = pack("H*", $hexdigest);
  47     my $len = length($checksum);
  48     $len == $ref->{bytelen} or
  49         die "invalid checksum length=$len (expected $ref->{bytelen})";
  50
  51     bless {
  52         fidid => $fidid,
  53         checksum => $checksum,
  54         hashtype => $NAME2TYPE{$hashname},
  55     }, $class;
  56 }
  57
  58 sub hashname {
  59     my $self = shift;
  60     my $type = $self->{hashtype};
  61     my $name = $TYPE2NAME{$type} or die "hashtype=$type unknown";
  62
  63     return $name;
  64 }
  65
  66 sub save {
  67     my $self = shift;
  68     my $sto = Mgd::get_store();
  69
  70     $sto->set_checksum($self->{fidid}, $self->{hashtype}, $self->{checksum});
  71 }
  72
  73 sub maybe_save {
  74     my ($self, $dmid, $classid) = @_;
  75     my $class = eval { Mgd::class_factory()->get_by_id($dmid, $classid) };
  76
  77     # $class may be undef as it could've been deleted between
  78     # create_open and create_close, we've never verified this before...
  79     # class->{hashtype} is also undef, as we allow create_close callers
  80     # to specify a hash regardless of class.
  81     if ($class && defined($class->{hashtype}) && $self->{hashtype} eq $class->{hashtype}) {
  82         $self->save;
  83     }
  84 }
  85
  86 sub hexdigest {
  87     my $self = shift;
  88
  89     unpack("H*", $self->{checksum});
  90 }
  91
  92 sub as_string {
  93     my $self = shift;
  94     my $name = $self->hashname;
  95     my $hexdigest = $self->hexdigest;
  96
  97     "Checksum[f=$self->{fidid};$name=$hexdigest]"
  98 }
  99
 100 sub info {
 101     my $self = shift;
 102
 103     $self->hashname . ':' . $self->hexdigest;
 104 }
 105
 106 1;
 107
 108 __END__
 109
 110 =head1 NAME
 111
 112 MogileFS::Checksum - Checksums handling for MogileFS
 113
 114 =head1 ABOUT
 115
 116 MogileFS supports optional MD5 checksums.  Checksums can be stored
 117 in the database on a per-class basis or they can be enabled globally
 118 during fsck-only.
 119
 120 Enabling checksums will greatly increase the time and I/O required for
 121 fsck as all files on all devices to be checksummed need to be reread.
 122
 123 Fsck and replication will use significantly more network bandwidth if
 124 the mogstored is not used or if mogstored_stream_port is
 125 not configured correctly.  Using Perlbal to 1.80 or later for HTTP
 126 will also speed up checksum verification during replication using
 127 the Content-MD5 HTTP header.
 128
 129 =head1 ALGORITHMS
 130
 131 While we can easily enable some or all of the SHA family of hash
 132 algorithms, they all perform worse than MD5.  Checksums are intended to
 133 detect unintentional corruption due to hardware/software errors, not
 134 malicious data replacement.  Since MogileFS does not implement any
 135 security/authorization on its own to protect against malicious use, the
 136 use of checksums in MogileFS to protect against malicious data
 137 replacement is misguided.
 138
 139 If you have a use case which requires a stronger hash algorithm,
 140 please speak up on the mailing list at L<mogile@googlegroups.com>.