SuperCrypt

[code]<?php

function super_encrypt( $input )
{
	$input		= str_rot13( $input ); // Verschuif alle letters 13 plaatsen naar rechts.
	
	$input_bits = '';
	
	for( $i = 0; $i < strlen( $input ); $i++ )
	{
		$input_bits[] = zero_pad( base_convert( ord( $input{$i} ), 10, 2 ) , 8 );
	}

	$input_bits = implode( '', $input_bits );
	$bit_total_length	= strlen( $input_bits );
	
	// Genereer de data voor de Bit Shift Group.
	$shift_bits			= rand( 0, floor( $bit_total_length / 2 ) ) + 1;
	$shift_direction	= rand( 0, 1 );
	
	// Compile de Bit Shift Group data tot binaire data.
	$string_to_compile	= 's:' . $shift_bits . '|d:' . $shift_direction;
	$bit_shift_group	= '';
	
	for( $i = 0; $i < strlen( $string_to_compile ); $i++ )
	{
		$bit_shift_group .= zero_pad( ord( $string_to_compile{ $i } ), 3 );
	}
	
	$bit_shift_group = new_base_convert( $bit_shift_group, 10, 2 );
	// Sla de lengte van de Bit Shift Group op.
	$bit_shift_group_l	= strlen( $bit_shift_group );
	
	// Voer een ingewikkelde berekening uit om de grootte van elke bitlocator te bepalen en om de hoeveel bits het moet komen.
	$bsg_group_size		= 2;
	$bsg_bits_between	= 8;
	$bsg_pos_found		= false;
	
	do
	{
		$total_num_of_blocks	= ceil( $bit_shift_group_l / $bsg_group_size ); // Aantal nodige blocks met deze specs.
		$max_num_of_blocks		= floor( $bit_total_length / ( $bsg_group_size + $bsg_bits_between ) ) - 1;
		
		if( $max_num_of_blocks > ( $total_num_of_blocks * 2 ) )
		{
			if( $bsg_group_size > 1 )
			{
				$bsg_group_size--;
			}
			else
			{
				$bsg_bits_between++;
				$max_num_of_blocks		= floor( $bit_total_length / ( $bsg_group_size + $bsg_bits_between ) ) - 1;
				
				if( $max_num_of_blocks > $total_num_of_blocks )
				{
					$bsg_pos_found = true;
				}
				else
				{
					$bsg_bits_between--;
					$bsg_pos_found = true;
				}
			}
		}
		elseif( $max_num_of_blocks >= $total_num_of_blocks )
		{
			$bsg_bits_between--;
			$max_num_of_blocks		= floor( $bit_total_length / ( $bsg_group_size + $bsg_bits_between ) ) - 1;
				
			if( $max_num_of_blocks > $total_num_of_blocks )
			{
				$bsg_pos_found = true;
			}
			else
			{
				$bsg_bits_between++;
				$bsg_pos_found = true;
			}
		}
		elseif( $max_num_of_blocks < $total_num_of_blocks )
		{
			$bsg_group_size++;
		}
		else
		{
			$bsg_bits_between--;
		}
	}
	while( $bsg_pos_found != true );
	
	// We hebben nu voldoende data om de header te gaan opbouwen.
	$header_first_group		= rand( 0, 1 ); // Dit bevat welke bitgroep eerst komt.
	$header_bits_between	= zero_pad( base_convert( $bsg_bits_between, 10, 2 ), 8 );
	$header_block_size		= zero_pad( base_convert( $bsg_group_size, 10, 2 ), 7 );
	$header 				= '1' . $header_first_group;
	
	if( $header_first_group === 1 )
	{
		$header .= $header_bits_between . $header_block_size;
	}
	else
	{
		$header .= $header_block_size . $header_bits_between;
	}
		
	// Shift de bits in de goede richting.
	if( $shift_direction === 1 )
	{
		$input_bits = shift_right( $input_bits, $shift_bits );
	}
	else
	{
		$input_bits = shift_left( $input_bits, $shift_bits );
	}
	
	$input_bit_blocks	= explode( '||', wordwrap( $input_bits, $bsg_bits_between, '||', 1 ) );
	$tot_num_bsg_blocks	= count( $input_bit_blocks ) - 1;
	$bit_shift_group	= zero_pad( $bit_shift_group, ( $tot_num_bsg_blocks * ( $bsg_group_size ) ) );
	$input_bsg_blocks	= explode( '||', wordwrap( $bit_shift_group, $bsg_group_size, '||', 1 ) );
	$output_string		= '';

	for( $i = 0; $i < count( $input_bit_blocks ); $i++ )
	{
		$output_string .= $input_bit_blocks[ $i ] . $input_bsg_blocks[ $i ];
	}

	$output_string = new_base_convert( $header . $output_string, 2, 36 );
	
	return $output_string;
}

function super_decrypt( $input )
{
	// Converteer de string naar bits.
	$input_bits = new_base_convert( $input, 36, 2 );
	
	// Decode de header.
	$header_block_first = substr( $input_bits, 1, 1 );
	
	if( $header_block_first === '0' )
	{
		$header_block_size		= intval( base_convert( substr( $input_bits, 2, 7 ), 2, 10 ) );
		$header_bits_between	= intval( base_convert( substr( $input_bits, 9, 8 ), 2, 10 ) );
	}
	else
	{
		$header_bits_between	= intval( base_convert( substr( $input_bits, 2, 8 ), 2, 10 ) );
		$header_block_size		= intval( base_convert( substr( $input_bits, 10, 7 ), 2, 10 ) );
	}

	$input_bits			= substr( $input_bits, 17, strlen( $input_bits ) - 17 );
	$input_bit_blocks	= explode( '||', wordwrap( $input_bits, intval( $header_bits_between + $header_block_size ), '||', 1 ) );
	$bsg_string			= '';
	$output_bits		= '';
	
	for( $i = 0; $i < count( $input_bit_blocks ); $i++ )
	{
		//echo substr( $input_bit_blocks[ $i ], 0, $header_bits_between ) . '<br />';
		$bsg_string .= substr( $input_bit_blocks[ $i ], $header_bits_between, $header_block_size );
		$output_bits .= substr( $input_bit_blocks[ $i ], 0, $header_bits_between );
	}

	$bsg_string			= new_base_convert( $bsg_string, 2, 10 );
	$bsg_string_ltrs	= explode( '||', wordwrap( $bsg_string, 3, '||', 1 ) );
	$bsg_string			= '';

	for( $i = 0; $i < count( $bsg_string_ltrs ); $i++ )
	{
		$bsg_string .= chr( intval( $bsg_string_ltrs[ $i ] ) );
	}
	
	$bsg_str_parts = explode( '|', $bsg_string );
	
	for( $i = 0; $i < count( $bsg_str_parts ); $i++ )
	{
		$parts = explode( ':', $bsg_str_parts[$i] );
		
		switch( $parts[0] )
		{
			case 's':
				$shift_bits = intval( $parts[1] );
				break;
			case 'd':
				if( intval( $parts[1] ) === 1 )
				{
					$output_bits = shift_left( $output_bits, $shift_bits );
				}
				else
				{
					$output_bits = shift_right( $output_bits, $shift_bits );
				}
				break;
		}
	}

	$output_bits_parts	= explode( '||', wordwrap( $output_bits, 8, '||', 1 ) );
	$output_bits		= '';
	
	for( $i = 0; $i < count( $output_bits_parts ); $i++ )
	{
		$output_bits .= chr( new_base_convert( $output_bits_parts[ $i ], 2, 10 ) );
	}

	return str_rot13( $output_bits );
}

function new_base_convert( $numstring, $frombase, $tobase )
{
	$chars		= "0123456789abcdefghijklmnopqrstuvwxyz";
	$tostring	= substr($chars, 0, $tobase);
	
	$length		= strlen( $numstring );
	$result		= '';
	
	for ( $i = 0; $i < $length; $i++ )
	{
		$number[ $i ] = strpos( $chars, $numstring{$i} );
	}
	
	do
	{
		$divide = 0;
		$newlen = 0;
		
		for ( $i = 0; $i < $length; $i++ )
		{
			$divide = $divide * $frombase + $number[$i];
			
			if ( $divide >= $tobase )
			{
				$number[ $newlen++ ] = (int)( $divide / $tobase );
				$divide = $divide % $tobase;
			}
			elseif ( $newlen > 0 )
			{
				$number[ $newlen++ ] = 0;
			}
		}
		
		$length = $newlen;
		$result = $tostring{ $divide } . $result;
	}
	while ( $newlen != 0 );
	return $result;
}

function shift_right( $str, $times = 1 )
{
	if( $times < 1 ) return $str;
	
	for( $i = 0; $i < $times; $i++ )
	{
		$right_bit	= substr( $str, strlen( $str ) -1, 1 );
		$str		= substr( $str, 0, strlen( $str ) -1 );
		$str		= $right_bit . $str;
	}
	return $str;
}

function shift_left( $str, $times = 1 )
{
	if( $times < 1 ) return $str;
	
	for( $i = 0; $i < $times; $i++ )
	{
		$left_bit	= substr( $str, 0, 1 );
		$str		= substr( $str, 1, strlen( $str ) -1 );
		$str		= $str . $left_bit;
	}
	return $str;
}

function zero_pad( $num, $limit )
{
	return ( strlen( $num ) >= $limit ) ? $num : zero_pad( '0' . $num, $limit );
}


//Klein voorbeeldje hoe het gebruikt moet worden.
$string = 'abcdefghijklmnopqrstuvwxyz';

$encrypt = super_encrypt( $string );
$decrypt = super_decrypt( $encrypt );
echo 'Geencrypt: ' . $encrypt . '<br />';
echo 'Gedecrypt: ' . $decrypt;
?>[/code]

De credits voor de new_base_convert functie gaan naar PHP.net. (kijk bij de comments van base_convert, de oorspronkelijke functie heette "unfucked_base_convert").