Şifreleyici Sınıfı

<?php
class Sifreleyici{
	private $_anahtar;
	public function __construct($anahtar = '', $md5 = true){
		$anahtar = str_split($md5 ? md5($anahtar) : sha1($anahtar), 1);
		$sinyal = false;
		$toplam = 0;
		foreach($anahtar as $karakter){
			if($sinyal){
				$toplam -= ord($karakter);
				$sinyal = false;
			}else{
				$toplam += ord($karakter);
				$sinyal = true;
			}
		}
		$this->_anahtar = abs($toplam);
	}
	public function sifrele($metin){
		$metin = str_split($metin, 1);
		$sonuc = '';
		foreach($metin as $karakter){
			$sonuc .= sprintf("%03x", ord($karakter) + $this->_anahtar);
		}
		return $sonuc;
	}
	public function coz($metin){
		$sonuc = '';
		$metin = str_split($metin, 3);
		foreach($metin as $karakter){
			$sonuc .= chr(hexdec($karakter) - $this->_anahtar);
		}
		return $sonuc;
	}
}
$anahtar = "asd";
$metin = "MerhabaDünya";
$s = new Sifreleyici($anahtar);
echo $es = $s->sifrele($metin);
echo "<br>";
echo $des = $s->coz($es);
?>

Çıktısı

 

Zamana ve Anahtara Göre Değişken Şifreleme Sınıfı

<?php
class Sifreleyici{
	var $anahtar;
	function Sifreleyici($anahtar){
		$this->anahtar = $anahtar;
		}
	function anahtardegistir($anahtar){
		$this->anahtar = $anahtar;
	}
	function anahtarED($metin) { 
		$sifrele_anahtar = md5($this->anahtar); 
		$ctr=0; 
		$topla = ""; 
		for ($i=0;$i<strlen($metin);$i++) { 
			if ($ctr==strlen($sifrele_anahtar)) $ctr=0; 
			$topla.= substr($metin,$i,1) ^ substr($sifrele_anahtar,$ctr,1); 
			$ctr++; 
		} 
		return $topla; 
	} 
	function sifrele($metin){ 
		srand((double)microtime()*1000000); 
		$sifrele_anahtar = md5(rand(0,32000)); 
		$ctr=0; 
		$topla = ""; 
		for ($i=0;$i<strlen($metin);$i++){ 
			if ($ctr==strlen($sifrele_anahtar)) $ctr=0; 
			$topla.= substr($sifrele_anahtar,$ctr,1) . 
			(substr($metin,$i,1) ^ substr($sifrele_anahtar,$ctr,1)); 
			$ctr++; 
		} 
		return base64_encode($this->anahtarED($topla)); 
	} 
	function coz($metin) { 
		$metin = $this->anahtarED(base64_decode($metin)); 
		$topla = ""; 
		for ($i=0;$i<strlen($metin);$i++){ 
			$md5 = substr($metin,$i,1); 
			$i++; 
			$topla.= (substr($metin,$i,1) ^ $md5); 
		} 
		return $topla; 
	} 
}
$c=new Sifreleyici("asd");
echo $c->sifrele("12345678");
echo $c->coz("VGoJPwM/B2ACNl8+BWhSOQ==");
?>

Çıktısı

VGoJPwM/B2ACNl8+BWhSOQ==
12345678

 

Kullanıcı Tanımlı MD5 Şifreleme

<?php
define("ktMD5_CODE","GuvenliKodBuraya"); //Your eMD5 server-side code
function ktMD5($metin){
	return ktMD5::hash($metin);
}
class ktMD5 {
	static function ikili($metin){
		$cikti=null;
		$i=0;while($i < strlen($metin)){
			$cikti .= "+". str_pad(decbin(ord(substr($metin,$i++,1))), 8, "0", STR_PAD_LEFT);
		}
		return $cikti;
	}
	static function dogrula($metin1,$metin2){ 
		if($metin1 != "+" && $metin2 != "+"){ 
			if($metin1 xor $metin2){
				return "1"; 
			}else{
				return "0"; 
			} 
		}else{
			return "+"; 
		} 
	}
	static function hash($metin){
		if(!defined("ktMD5_CODE")){exit("<b>hata: </b> ktMD5_code tanımlanmadı");}
		$metin = trim($metin);$s = md5(ktMD5_CODE);$metin = md5($metin);
		$i=0;while($i != 32){$dizi_metin[] = substr($metin,$i,8);$i=$i+8;}
		$i=0;while($i != 32){$dizi_s[] = substr($s,$i,8);$i=$i+8;}
		$metin1 = ktMD5::ikili($dizi_s[0].$dizi_metin[1].$dizi_s[2].$dizi_metin[3]);
		$metin2 = ktMD5::ikili($dizi_metin[0].$dizi_s[1].$dizi_metin[2].$dizi_s[3]);
		$kombin=null;
		$e=0;
		while($e < strlen($metin1)){ 
			$kombin .= ktMD5::dogrula(substr($metin1,$e,1),substr($metin2,$e,1)); 
			$e++; 
		}
		$cikti = md5($kombin);
		return $cikti;
	}
}
echo MD5("1234568");
echo "<br>";
echo ktMD5("1234568");
?>

Çıktısı

fe743d8d97aa7dfc6c93ccdc2e749513
e32f8d4f9b769346a74fe8d1a82c5e56

 

Özelleştirilmiş Şifre Üretici

<?php
class SifreUretici{
	var $wc;
	var $w;
	var $l;
	var $minl;
	var $maxl;
	function SifreUretici($min, $max, $dizi=NULL){
		if($dizi == NULL){
			$this->wc = array('_','-'); // special chars
			for($i=48; $i<58; $i++){
				array_push($this->wc, chr($i)); // 0-9
			}
			for($i=65; $i<91; $i++){
				array_push($this->wc, chr($i)); // A-Z
      }    
			for($i=97; $i<122; $i++){
				array_push($this->wc, chr($i)); // a-z
      }    
			shuffle($this->wc);
		}
		else{ 
			$this->wc = $dizi; 
		}
		$this->minl = $min;
		$this->maxl = $max;
	}
	function olustur(){
		$this->w = NULL; 
		$this->l = rand($this->minl, $this->maxl); 
		for($i=0; $i<$this->l; $i++){
			$no = rand(0, count($this->wc)-1);
			$this->w .= $this->wc[$no];
		}
		return htmlentities($this->w);
	}
}
$s = new SifreUretici(10, 16); //10-16 karakter arası şifre üretir.
echo $s->olustur();
echo "<br>";
$dizi = array('a','b','1','!'); // Sadece bu karakterlerden 8 haneli şifre üretir
$s = new SifreUretici(8,8,$dizi);
echo $s->olustur();
echo "<br>";
?>

Çıktısı

f_aDfXWCmKK4t
!bb!1ab1

 

Rastgele Şifre Oluşturma,Tuzlu Şifreleme ve Doğrulama

<?php
class Sifre {
	var $tuz;
  function sifrele($sifre, $tuz = '') {
		$this->tuz=$tuz;
    $buyu = '$1$';
    $karakterler = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    if (strlen($this->tuz) < 8) {
      mt_srand ((double) microtime() * 1000000);
      for ($i = 8; $i > strlen($this->tuz);) {
        $this->tuz .= $karakterler{mt_rand (0, strlen($karakterler)-1)};
      }
    }
    $passwd = crypt($sifre, $buyu . $this->tuz);
    return($passwd);
  }
  function kontrol($sifre, $sifreli) {
    $test = $this->sifrele($sifre, substr($sifreli, 3, 8));
    if ($test == $sifreli) {
      return(true);
    }else{
      return(false);
    }
  }
  function rastgeleSifreUret() {
    $karakterler = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
    $this->tuz=mt_srand ((double) microtime() * 1000000);
    for ($i = 8; $i > strlen($this->tuz);) {
      $this->tuz .= $karakterler{mt_rand (0, strlen($karakterler)-1)};
    }
    return($this->tuz);
  }
}
$p = new Sifre;
echo $rastgele= $p->rastgeleSifreUret();
echo "<br>";
echo $sifreli = $p->sifrele($rastgele,$tuz=rand(1,2));
echo "<br>";
if ($p->kontrol($rastgele,$sifreli)) {
echo "Doğru Şifre";
}else{
echo "Hatalı Şifre";
}
?>

Çıktısı

h95Pjaec
$1$1xuDtzzC$VcOdiz8wCJRBZgdHhYjWt1
Doğru Şifre

 

Sipariş Algoritmalarında Dinamik Fiyat Kontrolü

Bu sınıf, E-Ticaret ağ geçidine dinamik fiyatla sipariş vermek için gerekli olan MD5 algoritmasını kullanarak fiyat kontrolleri üretmeyi amaçlamaktadır.

<?php 
define ('NET', 'N');
define ('BRUT', 'B');
class dinamikFiyat {
	var $urunNumarasi='';
	var $fiyatlar=array();
	var $fiyatTipi=NET;
	var $sifre='';
	function MD5saglamaToplami(){
		$fiyatlar=implode(',',$this->fiyatlar).','.$this->fiyatTipi;
		$metin=$this->urunNumarasi.'#'.$fiyatlar.'#'.$this->sifre;	
		return md5($metin);
	}
	function fiyatEkle($fiyat) {
		$this->fiyatlar[]=$fiyat; 
	}
}
$dinamikFiyat = new dinamikFiyat ();
$dinamikFiyat->urunNumarasi = '103'; 
$dinamikFiyat->fiyatTipi = NET;
$dinamikFiyat->sifre = '12345678'; 
$dinamikFiyat->fiyatEkle ('12TRY');
echo $dinamikFiyat->MD5saglamaToplami()."<br>";
echo $dinamikFiyat->urunNumarasi."<br>";
echo $dinamikFiyat->fiyatTipi."<br>";
echo $dinamikFiyat->sifre."<br>";
print_r($dinamikFiyat->fiyatlar);
?>

Çıktısı

27adbf13e9556f4eef2fe30ce5c8b1f7
103
N
12345678
Array ( [0] => 12TRY )

 

Şifreleri Şifrelemek ve Çözmek

<?php
class Sifre{
   var $k;
   function Sifre($m){
      $this->k = $m;
   }
   function ed($t) { 
      $r = md5($this->k); 
      $c=0; 
      $v = ""; 
      for ($i=0;$i<strlen($t);$i++) { 
         if ($c==strlen($r)) $c=0; 
         $v.= substr($t,$i,1) ^ substr($r,$c,1); 
         $c++; 
      } 
      return $v; 
   } 
   function sifrele($t){ 
      srand((double)microtime()*1000000); 
      $r = md5(rand(0,32000)); 
      $c=0; 
      $v = ""; 
      for ($i=0;$i<strlen($t);$i++){ 
         if ($c==strlen($r)) $c=0; 
         $v.= substr($r,$c,1) . 
             (substr($t,$i,1) ^ substr($r,$c,1)); 
         $c++; 
      } 
      return base64_encode($this->ed($v)); 
   } 
   function coz($t) { 
      $t = $this->ed(base64_decode($t)); 
      $v = ""; 
      for ($i=0;$i<strlen($t);$i++){ 
         $md5 = substr($t,$i,1); 
         $i++; 
         $v.= (substr($t,$i,1) ^ $md5); 
      } 
      return $v; 
   } 
}
$sifre = "123456";
$cr64 = new Sifre($sifre);
$e = $cr64->sifrele($sifre);
echo "Şifreli = ".$e."<br>";
$d = $cr64->coz($e);
echo "Çözülmüş = ".$d."<br>";
?>

Çıktısı

Şifreli = UzYGZVBkAT8AOFBl
Çözülmüş = 123456

 

İstenilen Karakter ve Uzunluğa Göre Anahtar Şifreleme

<?php
class anahtar{
	var $anahtar = "";
	var $karakterler = array("1","2","3","8","5","6","7","8","9",
                    "a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z",
                    "A","B","C","D","E","F","G","H","I","J","K","L","M","N","P","Q","R","S","T","U","V","W","X","Y","Z");
  function anahtar($boyut){
    for ($i = 0; $i<$boyut; $i++){
        $this->anahtar .= $this->karakterler[rand(0,count($this->karakterler)-1)];
    }
  }
}
$sifre = new anahtar(7);
echo $sifre->anahtar;
?>

Çıktısı

XIhHxmc

 

WordPress Unutulan Şifre Üretici Phpass

indir

Unutulan wordpress şifrelerinizi el ile phpmyadmin’den bu kod yardımıyla değiştirebilirsiniz.

<?php
class PasswordHash {
 var $itoa64;
 var $iteration_count_log2;
 var $portable_hashes;
 var $random_state;
 function PasswordHash($iteration_count_log2, $portable_hashes)
 {
 $this->itoa64 = './0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';

 if ($iteration_count_log2 < 4 || $iteration_count_log2 > 31)
 $iteration_count_log2 = 8;
 $this->iteration_count_log2 = $iteration_count_log2;
 $this->portable_hashes = $portable_hashes;
 $this->random_state = microtime() . uniqid(rand(), TRUE); // removed getmypid() for compatibility reasons
 }
 function get_random_bytes($count)
 {
 $output = '';
 if ( @is_readable('/dev/urandom') &&
 ($fh = @fopen('/dev/urandom', 'rb'))) {
 $output = fread($fh, $count);
 fclose($fh);
 }
 if (strlen($output) < $count) {
 $output = '';
 for ($i = 0; $i < $count; $i += 16) {
 $this->random_state =
 md5(microtime() . $this->random_state);
 $output .=
 pack('H*', md5($this->random_state));
 }
 $output = substr($output, 0, $count);
 }
 return $output;
 }
 function encode64($input, $count)
 {
 $output = '';
 $i = 0;
 do {
 $value = ord($input[$i++]);
 $output .= $this->itoa64[$value & 0x3f];
 if ($i < $count)
 $value |= ord($input[$i]) << 8;
 $output .= $this->itoa64[($value >> 6) & 0x3f];
 if ($i++ >= $count)
 break;
 if ($i < $count)
 $value |= ord($input[$i]) << 16;
 $output .= $this->itoa64[($value >> 12) & 0x3f];
 if ($i++ >= $count)
 break;
 $output .= $this->itoa64[($value >> 18) & 0x3f];
 } while ($i < $count);

 return $output;
 }
 function gensalt_private($input)
 {
 $output = '$P$';
 $output .= $this->itoa64[min($this->iteration_count_log2 +
 ((PHP_VERSION >= '5') ? 5 : 3), 30)];
 $output .= $this->encode64($input, 6);

 return $output;
 }
 function crypt_private($password, $setting)
 {
 $output = '*0';
 if (substr($setting, 0, 2) == $output)
 $output = '*1';
 $id = substr($setting, 0, 3);
 if ($id != '$P$' && $id != '$H$')
 return $output;
 $count_log2 = strpos($this->itoa64, $setting[3]);
 if ($count_log2 < 7 || $count_log2 > 30)
 return $output;
 $count = 1 << $count_log2;
 $salt = substr($setting, 4, 8);
 if (strlen($salt) != 8)
 return $output;
 if (PHP_VERSION >= '5') {
 $hash = md5($salt . $password, TRUE);
 do {
 $hash = md5($hash . $password, TRUE);
 } while (--$count);
 } else {
 $hash = pack('H*', md5($salt . $password));
 do {
 $hash = pack('H*', md5($hash . $password));
 } while (--$count);
 }
 $output = substr($setting, 0, 12);
 $output .= $this->encode64($hash, 16);
 return $output;
 }
 function gensalt_extended($input)
 {
 $count_log2 = min($this->iteration_count_log2 + 8, 24);
 $count = (1 << $count_log2) - 1;
 $output = '_';
 $output .= $this->itoa64[$count & 0x3f];
 $output .= $this->itoa64[($count >> 6) & 0x3f];
 $output .= $this->itoa64[($count >> 12) & 0x3f];
 $output .= $this->itoa64[($count >> 18) & 0x3f];
 $output .= $this->encode64($input, 3);
 return $output;
 }
 function gensalt_blowfish($input)
 {
 $itoa64 = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
 $output = '$2a$';
 $output .= chr(ord('0') + $this->iteration_count_log2 / 10);
 $output .= chr(ord('0') + $this->iteration_count_log2 % 10);
 $output .= '$';
 $i = 0;
 do {
 $c1 = ord($input[$i++]);
 $output .= $itoa64[$c1 >> 2];
 $c1 = ($c1 & 0x03) << 4;
 if ($i >= 16) {
 $output .= $itoa64[$c1];
 break;
 }
 $c2 = ord($input[$i++]);
 $c1 |= $c2 >> 4;
 $output .= $itoa64[$c1];
 $c1 = ($c2 & 0x0f) << 2;
 $c2 = ord($input[$i++]);
 $c1 |= $c2 >> 6;
 $output .= $itoa64[$c1];
 $output .= $itoa64[$c2 & 0x3f];
 } while (1);

 return $output;
 }
 function HashPassword($password)
 {
 $random = '';
 if (CRYPT_BLOWFISH == 1 && !$this->portable_hashes) {
 $random = $this->get_random_bytes(16);
 $hash =
 crypt($password, $this->gensalt_blowfish($random));
 if (strlen($hash) == 60)
 return $hash;
 }
 if (CRYPT_EXT_DES == 1 && !$this->portable_hashes) {
 if (strlen($random) < 3)
 $random = $this->get_random_bytes(3);
 $hash =
 crypt($password, $this->gensalt_extended($random));
 if (strlen($hash) == 20)
 return $hash;
 }
 if (strlen($random) < 6)
 $random = $this->get_random_bytes(6);
 $hash =
 $this->crypt_private($password,
 $this->gensalt_private($random));
 if (strlen($hash) == 34)
 return $hash;
 return '*';
 }
 function CheckPassword($password, $stored_hash)
 {
 $hash = $this->crypt_private($password, $stored_hash);
 if ($hash[0] == '*')
 $hash = crypt($password, $stored_hash);
 return $hash === $stored_hash;
 }
}
$password="12345678";//buraya istediğiniz şifre
$wp_hasher = new PasswordHash( 8, true );
$hashed = $wp_hasher->HashPassword( $password );
if($wp_hasher->CheckPassword($password, $hashed)){echo "Doğru Şifre";}else{echo "Hatalı Şifre";}

echo "<br>Şifreniz: ".$password;
echo "<br>Veritabanı Kodunuz: ".$hashed;//mysql wp_users.user_pass kısmına yazabileceğiniz hash(veritabanına eklenecek şifre karma kodu)
?>