Gecko [ edgpens.lpkmn.gov.my ]

Name	Size	Permission
ES	[ DIR ]	drwxrwxrwx
Key	[ DIR ]	drwxrwxrwx
SS	[ DIR ]	drwxrwxrwx
.mad-root	0 B	-rw-rw-rw-
DataFormat.pm	4.97 KB	-rw-rw-rw-
Debug.pm	1.55 KB	-rw-rw-rw-
Errorhandler.pm	2.97 KB	-rw-rw-rw-
Key.pm	8 KB	-rw-rw-rw-
Primitives.pm	3.61 KB	-rw-rw-rw-

Code Editor : DataFormat.pm

package Crypt::RSA::DataFormat; 
use strict;
use warnings;

## Crypt::RSA::DataFormat -- Functions for converting, shaping and 
##                           creating and reporting data formats.
##
## Copyright (c) 2001, Vipul Ved Prakash.  All rights reserved.
## This code is free software; you can redistribute it and/or modify
## it under the same terms as Perl itself.

use vars qw(@ISA);
use Math::BigInt try => 'GMP, Pari';
use Math::Prime::Util qw/random_bytes/;
use Digest::SHA qw(sha1);
use Carp;

use base qw(Exporter);
our @EXPORT_OK = qw(i2osp os2ip h2osp octet_xor octet_len bitsize 
                    generate_random_octet mgf1 steak);

sub i2osp {
    my ($num, $l) = @_;
    $num = 0 if !defined $num;
    $l   = 0 if !defined $l;
    my $result;

if (ref($num) ne 'Math::BigInt' && $num <= ~0) {
      $result = '';
      do {
        $result = chr($num & 0xFF) . $result;
        $num >>= 8;
      } while $num;
    } else {
      $num = Math::BigInt->new("$num") unless ref($num) eq 'Math::BigInt';
      my $hex = $num->as_hex;
      # Remove the 0x and any leading zeros (shouldn't be any)
      $hex =~ s/^0x0*//;
      # Add a leading zero if needed to line up bytes correctly.
      substr($hex, 0, 0, '0') if length($hex) % 2;
      # Pack hex string into a octet string.
      $result = pack("H*", $hex);
    }

if ($l) {
      my $rlen = length($result);
      # Return undef if too large to fit
      return if $l < $rlen;
      # Zero pad the front if they want a longer string
      substr( $result, 0, 0, chr(0) x ($l-$rlen) ) if $rlen < $l;
    }
    return $result;
}

sub os2ip {
    my $string = shift;
    my($hex) = unpack('H*', $string);
    return Math::BigInt->new("0x$hex");
}

sub h2osp { 
    my $hex = shift;
    $hex =~ s/\s//g;
    $hex =~ s/^0x0*//;
    # Add a leading zero if needed to line up bytes correctly.
    substr($hex, 0, 0, '0') if length($hex) % 2;
    # Pack into a string.
    my $result = pack("H*", $hex);
    return $result;
}

sub generate_random_octet {
  my $l = shift;   # Ignore the strength parameter, if any
  return random_bytes($l);
}

sub bitsize {
  my $n = shift;
  my $bits = 0;
  if (ref($n) eq 'Math::BigInt') {
    $bits = length($n->as_bin) - 2;
  } else {
    while ($n) { $bits++; $n >>= 1; }
  }
  $bits;
}

sub octet_len { 
  return int( (bitsize(shift) + 7) / 8 );
}

# This could be made even faster doing 4 bytes at a time
sub octet_xor {
    my ($a, $b) = @_;

# Ensure length($a) >= length($b)
    ($a, $b) = ($b, $a) if length($b) > length($a);
    my $alen = length($a);
    # Prepend null bytes to the beginning of $b to make the lengths equal
    substr($b, 0, 0, chr(0) x ($alen-length($b))) if $alen > length($b);

# xor all bytes
    my $r = '';
    $r .= chr( ord(substr($a,$_,1)) ^ ord(substr($b,$_,1)) ) for 0 .. $alen-1;
    return $r;
}

# http://rfc-ref.org/RFC-TEXTS/3447/chapter11.html
sub mgf1 {
    my ($seed, $l) = @_;
    my $hlen = 20;  # SHA-1 is 160 bits
    my $imax = int(($l + $hlen - 1) / $hlen) - 1;
    my $T = "";
    foreach my $i (0 .. $imax) {
      $T .= sha1($seed . i2osp ($i, 4));
    }
    my ($output) = unpack "a$l", $T;
    return $output;
}

sub steak { 
    my ($text, $blocksize) = @_; 
    my $textsize = length($text);
    my $chunkcount = $textsize % $blocksize 
        ? int($textsize/$blocksize) + 1 : $textsize/$blocksize;
    my @segments = unpack "a$blocksize"x$chunkcount, $text;
    return @segments;
}

=head1 NAME

Crypt::RSA::DataFormat - Data creation, conversion and reporting primitives.

=head1 DESCRIPTION

This module implements several data creation, conversion and reporting
primitives used throughout the Crypt::RSA implementation. Primitives are
available as exportable functions.

=head1 FUNCTIONS

=over 4

=item B<i2osp> Integer, Length

Integer To Octet String Primitive. Converts an integer into its
equivalent octet string representation of length B<Length>. If
necessary, the resulting string is prefixed with nulls. If
B<Length> is not provided, returns an octet string of shortest
possible length.

=item B<h2osp> Hex String

Hex To Octet String Primitive. Converts a I<hex string> into its
equivalent octet string representation and returns an octet
string of shortest possible length. The hex string is not
prefixed with C<0x>, etc.

=item B<os2ip> String

Octet String to Integer Primitive. Converts an octet string into its
equivalent integer representation.

=item B<generate_random_octet> Length

Generates a random octet string of length B<Length>.

=item B<bitsize> Integer

Returns the length of the B<Integer> in bits.

=item B<octet_len> Integer

Returns the octet length of the integer. If the length is not a whole
number, the fractional part is dropped to make it whole.

=item B<octet_xor> String1, String2

Returns the result of B<String1> XOR B<String2>.

=item B<steak> String, Length

Returns an array of segments of length B<Length> from B<String>. The final
segment can be smaller than B<Length>.

=back

=head1 AUTHOR

Vipul Ved Prakash, E<lt>mail@vipul.netE<gt>

=cut

${this.title}

Code Editor : DataFormat.pm