view release on metacpan or  search on metacpan

lib/Crypt/AppleTwoFish.pm  view on Meta::CPAN

                $bytes[ $j * 4 + $k ] = ( $h >> ( 24 - $k * 8 ) ) & 0xFF;
            }
        }
    }
    print "\nprecultivation bytes are ", ( join q{}, map { chr } @bytes ), "\n"
      if $self->{DEBUG};
    $bytes[0]  = $self->_hoe_hoe_hoe( $bytes[0],  0,  2, 0x99, 0xDF );
    $bytes[4]  = $self->_hoe_hoe_hoe( $bytes[4],  4,  3, 0xB5, 0xFF );
    $bytes[8]  = $self->_hoe_hoe_hoe( $bytes[8],  8,  4, 0x59, 0xD3 );
    $bytes[12] = $self->_hoe_hoe_hoe( $bytes[12], 12, 5, 0x2F, 0x1E );
    my $tmp = $bytes[1];
    $bytes[1]  = $self->_hoe_hoe_hoe( $bytes[5],  1,  6,  0x95, 0xFC );
    $bytes[5]  = $self->_hoe_hoe_hoe( $bytes[9],  5,  7,  0x05, 0x36 );
    $bytes[9]  = $self->_hoe_hoe_hoe( $bytes[13], 9,  0,  0x05, 0x6D );
    $bytes[13] = $self->_hoe_hoe_hoe( $tmp,       13, 9,  0x05, 0xE1 );
    $tmp       = $bytes[2];
    $bytes[2]  = $self->_hoe_hoe_hoe( $bytes[10], 2,  10, 0x4D, 0xB0 );
    $bytes[10] = $self->_hoe_hoe_hoe( $tmp,       10, 11, 0x0B, 0x2E );
    $tmp       = $bytes[6];
    $bytes[6]  = $self->_hoe_hoe_hoe( $bytes[14], 6,  12, 0x93, 0x4E );
    $bytes[14] = $self->_hoe_hoe_hoe( $tmp,       14, 13, 0x9b, 0x75 );

    $tmp = $bytes[3];
    $bytes[3]  = $self->_hoe_hoe_hoe( $bytes[15], 3,  14, 0x93, 0xC8 );
    $bytes[15] = $self->_hoe_hoe_hoe( $bytes[11], 15, 15, 0x33, 0x8B );
    $bytes[11] = $self->_hoe_hoe_hoe( $bytes[7],  11, 1,  0x5B, 0x25 );
    $bytes[7]  = $self->_hoe_hoe_hoe( $tmp,       7,  8,  0xED, 0xC5 );
    print "cultivated bytes are ", ( join q{}, map { chr } @bytes ), "\n"
      if $self->{DEBUG};
    return @bytes;
}

sub harvest_veggies {
    my ( $self, @bytes ) = @_;
    my $veggie = $self->{veggie};

    use integer;
    if ( $veggie =~ m/carrot|garlic|potato|radish|tomato/ ) {
        _till( \@bytes, $veggie );
    }

    _weed( \@bytes, $veggie );
    my $sha1 = Digest::SHA->new(1);
    $sha1->add( $self->{combine_key} );
    my @digest_bytes = map { ord } split //, $sha1->digest;
    _weed( \@digest_bytes, 'pepcid' );

    for my $i ( 0 .. 13 ) {
        my $a = $bytes[ $i + 2 ];
        my $b = $digest_bytes[ $i + 1 ];
        my $c = ( $a * 0xFFFF9129 + 0xA07E ) | 0xFF;
        my $d = ( $a * 0xFFAD8735 + 0x109ABD82 ) ^ $c;
        my $e = ( $a * 0xFFFF9129 + 0xA07E ) | ( $a * 0x5278CB + 0xEF65427D );
        my $f = $e | 0xFF;
        my $g = ( $b * 0xFFFFCB29 + 0x417E ) | 0xFF;
        my $h = ( $b * 0xFFFFCB29 + 0x417E ) | ( $b * 0x698AC6 + 0xD597C97D );
        my $j = $h | 0xFF;
        my $k = ( $b * 0xFF96753A + 0x2A683682 ) ^ $g;
        my $m =
          ( $b * 0xD2ABDE + $j * 0xFFFFFFFC + $k * 0xFFFFFFFE + 0xAB3015F3 ) |
          ( $a * 0xA413E8 + $d * 0xFFFFFFFE + $f * 0xFFFFFFFC + 0xDECBC5F3 );
        $digest_bytes[ $i + 1 ] = (
            (
                $a * 0x3FC1ACD4 +
                  $b * 0x5B76357 +
                  ( $d + $k + $m ) * 0x71070EE7 +
                  ( $f + $j ) * 0xE20E1DCE + 0xB7ABCB54
            )
        ) & 0xFF;
    }
    my $a     = ord substr $self->{hwID}, 4, 1;
    my $b     = $a * 0xFFFF9CFF + 0xB8FF;
    my $c     = $b | 0xFF;
    my $d     = $b | ( $a * 0x32FA52 + 0x21E2D7AB );
    my $e     = ( $a * 0xFFCD05AE + 0xDE1D2854 ) ^ $c;
    my $f     = $d | 0xFF;
    my $nsize = ( $a * 0xFFCD68AF + $e + $f * 2 + 0xDE1C6F57 ) & 0x80000003 + 8;
    use bigint;
    my $ndigest_bytes = '0x' . join q{},
      _dust( @digest_bytes[ 0 .. $nsize - 1 ] );
    $ndigest_bytes = substr $ndigest_bytes, 0, ( $nsize * 2 ) + 2;
    my $nd = Math::BigInt->new($ndigest_bytes);
    my $nbytes_str = '0x' . join q{},
      map { length $_ > 1 ? $_ : '0' . $_ } _dust(@bytes);
    my $nbytes = Math::BigInt->new($nbytes_str);
    # print "nbytes_str is $nbytes_str, nybytes is $nbytes\n" if $self->{DEBUG};
    my $nB2            = 0xFFFFFFFFFFFFFFF9C31A00000000000933CCD065;
    my $n00            = 0x100000000000000063CE600000000001DB577CE3F;
    my $n1             = 1;
    my $bits_in_digest = length( ( Math::BigInt->new($nd) )->as_bin ) - 2;

    for ( my $i = $bits_in_digest - 1 ; $i >= 0 ; --$i ) {
        $n1     *= $n1;
        $nbytes *= $nbytes;
        if ( $nd & ( 1 << $i ) ) {
            $n1 = $nbytes - $n1;
            my $m = ( ( ( $n1 >> 159 ) * $n00 ) >> 161 ) * $nB2;
            $n1 = ( $n1 - $m ) % $nB2;
            $m = ( ( ( $nbytes >> 159 ) * $n00 )>> 161 ) * $nB2;
            $nbytes = ( $nbytes - $m ) % $nB2;
        }
        else {
            $nbytes -= $n1;
            my $m = ( ( ( $nbytes >> 159 ) * $n00 ) >> 161 )* $nB2;
            $nbytes = ( $nbytes - $m )% $nB2;
            $m = ( ( ( $n1 >> 159 ) * $n00 ) >> 161 ) * $nB2;
            $n1 -= $m;
            $nbytes %= $nB2;
        }
    }    # now $n1 is right
    my @digits =
      ( substr( ( Math::BigInt->new($n1) )->as_hex, 2 ) ) =~ m/[\d\w]{2}/g;
    my $digit_count = scalar @digits;
    my $digest_fodder = join q{}, map { chr( hex $_ ) } @digits;
    if ( $digit_count < 32 ) {
        my $zeroes = "\x00" x ( 32 - $digit_count );
        $digest_fodder = $zeroes . $digest_fodder;
    }
    $sha1->reset;
    $sha1->add($digest_fodder);
    my $key_key = substr $sha1->digest, 1, 16;