src/Encoding.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace PhpMyAdmin;
   6
   7 use function array_filter;
   8 use function array_intersect;
   9 use function array_map;
  10 use function explode;
  11 use function fclose;
  12 use function feof;
  13 use function fgets;
  14 use function fopen;
  15 use function function_exists;
  16 use function fwrite;
  17 use function iconv;
  18 use function mb_convert_encoding;
  19 use function mb_convert_kana;
  20 use function mb_detect_encoding;
  21 use function mb_list_encodings;
  22 use function preg_replace;
  23 use function str_contains;
  24 use function str_starts_with;
  25 use function strtolower;
  26 use function strtoupper;
  27 use function tempnam;
  28 use function unlink;
  29
  30 /**
  31  * Encoding conversion helper class
  32  */
  33 class Encoding
  34 {
  35     public const ENGINE_NONE = 'none';
  36     public const ENGINE_ICONV = 'iconv';
  37     public const ENGINE_MBSTRING = 'mbstring';
  38
  39     /**
  40      * Chosen encoding engine
  41      *
  42      * @var self::ENGINE_NONE|self::ENGINE_ICONV|self::ENGINE_MBSTRING|null
  43      */
  44     private static string|null $engine = null;
  45
  46     /**
  47      * Map of conversion engine configurations
  48      *
  49      * Each entry contains:
  50      *
  51      * - function to detect
  52      * - engine contant
  53      * - extension name to warn when missing
  54      */
  55     private const ENGINE_MAP = [
  56         'iconv' => 'iconv',
  57         'mbstring' => 'mb_convert_encoding',
  58         'none' => 'isset',
  59     ];
  60
  61     /**
  62      * Order of automatic detection of engines
  63      */
  64     private const ENGINE_ORDER = ['iconv', 'mbstring'];
  65
  66     /**
  67      * Kanji encodings list
  68      */
  69     private static string $kanjiEncodings = 'ASCII,SJIS,EUC-JP,JIS';
  70
  71     /**
  72      * Initializes encoding engine detecting available backends.
  73      */
  74     public static function initEngine(): void
  75     {
  76         $engine = Config::getInstance()->config->RecodingEngine;
  77
  78         /* Use user configuration */
  79         if (isset(self::ENGINE_MAP[$engine])) {
  80             if (function_exists(self::ENGINE_MAP[$engine])) {
  81                 self::$engine = $engine;
  82
  83                 return;
  84             }
  85
  86             Core::warnMissingExtension($engine);
  87         }
  88
  89         /* Autodetection */
  90         foreach (self::ENGINE_ORDER as $engine) {
  91             if (function_exists(self::ENGINE_MAP[$engine])) {
  92                 self::$engine = $engine;
  93
  94                 return;
  95             }
  96         }
  97
  98         /* Fallback to none conversion */
  99         self::$engine = self::ENGINE_NONE;
 100     }
 101
 102     /**
 103      * Setter for engine. Use with caution, mostly useful for testing.
 104      *
 105      * @param self::ENGINE_NONE|self::ENGINE_ICONV|self::ENGINE_MBSTRING $engine
 106      */
 107     public static function setEngine(string $engine): void
 108     {
 109         self::$engine = $engine;
 110     }
 111
 112     /**
 113      * Checks whether there is any charset conversion supported
 114      */
 115     public static function isSupported(): bool
 116     {
 117         if (self::$engine === null) {
 118             self::initEngine();
 119         }
 120
 121         return self::$engine != self::ENGINE_NONE;
 122     }
 123
 124     /**
 125      * Converts encoding of text according to parameters with detected
 126      * conversion function.
 127      *
 128      * @param string $srcCharset  source charset
 129      * @param string $destCharset target charset
 130      * @param string $what        what to convert
 131      *
 132      * @return string   converted text
 133      */
 134     public static function convertString(
 135         string $srcCharset,
 136         string $destCharset,
 137         string $what,
 138     ): string {
 139         if ($srcCharset === $destCharset) {
 140             return $what;
 141         }
 142
 143         if (self::$engine === null) {
 144             self::initEngine();
 145         }
 146
 147         $config = Config::getInstance();
 148         $iconvExtraParams = '';
 149         if (str_starts_with($config->config->IconvExtraParams, '//')) {
 150             $iconvExtraParams = $config->config->IconvExtraParams;
 151         }
 152
 153         return match (self::$engine) {
 154             self::ENGINE_ICONV => iconv($srcCharset, $destCharset . $iconvExtraParams, $what),
 155             self::ENGINE_MBSTRING => mb_convert_encoding($what, $destCharset, $srcCharset),
 156             default => $what,
 157         };
 158     }
 159
 160     /**
 161      * Detects whether Kanji encoding is available
 162      */
 163     public static function canConvertKanji(): bool
 164     {
 165         return Current::$lang === 'ja';
 166     }
 167
 168     /**
 169      * Setter for Kanji encodings. Use with caution, mostly useful for testing.
 170      */
 171     public static function getKanjiEncodings(): string
 172     {
 173         return self::$kanjiEncodings;
 174     }
 175
 176     /**
 177      * Setter for Kanji encodings. Use with caution, mostly useful for testing.
 178      *
 179      * @param string $value Kanji encodings list
 180      */
 181     public static function setKanjiEncodings(string $value): void
 182     {
 183         self::$kanjiEncodings = $value;
 184     }
 185
 186     /**
 187      * Reverses SJIS & EUC-JP position in the encoding codes list
 188      */
 189     public static function kanjiChangeOrder(): void
 190     {
 191         $parts = explode(',', self::$kanjiEncodings);
 192         if ($parts[1] === 'EUC-JP') {
 193             self::$kanjiEncodings = 'ASCII,SJIS,EUC-JP,JIS';
 194
 195             return;
 196         }
 197
 198         self::$kanjiEncodings = 'ASCII,EUC-JP,SJIS,JIS';
 199     }
 200
 201     /**
 202      * Kanji string encoding convert
 203      *
 204      * @param string $str  the string to convert
 205      * @param string $enc  the destination encoding code
 206      * @param string $kana set 'kana' convert to JIS-X208-kana
 207      *
 208      * @return string   the converted string
 209      */
 210     public static function kanjiStrConv(string $str, string $enc, string $kana): string
 211     {
 212         if ($enc === '' && $kana === '') {
 213             return $str;
 214         }
 215
 216         $stringEncoding = mb_detect_encoding($str, self::$kanjiEncodings);
 217         if ($stringEncoding === false) {
 218             $stringEncoding = 'utf-8';
 219         }
 220
 221         if ($kana === 'kana') {
 222             $dist = mb_convert_kana($str, 'KV', $stringEncoding);
 223             $str = $dist;
 224         }
 225
 226         if ($stringEncoding !== $enc && $enc !== '') {
 227             return mb_convert_encoding($str, $enc, $stringEncoding);
 228         }
 229
 230         return $str;
 231     }
 232
 233     /**
 234      * Kanji file encoding convert
 235      *
 236      * @param string $file the name of the file to convert
 237      * @param string $enc  the destination encoding code
 238      * @param string $kana set 'kana' convert to JIS-X208-kana
 239      *
 240      * @return string   the name of the converted file
 241      */
 242     public static function kanjiFileConv(string $file, string $enc, string $kana): string
 243     {
 244         if ($enc === '' && $kana === '') {
 245             return $file;
 246         }
 247
 248         $tmpfname = (string) tempnam(Config::getInstance()->getUploadTempDir(), $enc);
 249         $fpd = fopen($tmpfname, 'wb');
 250         if ($fpd === false) {
 251             return $file;
 252         }
 253
 254         $fps = fopen($file, 'r');
 255         if ($fps === false) {
 256             return $file;
 257         }
 258
 259         self::kanjiChangeOrder();
 260         while (! feof($fps)) {
 261             $line = fgets($fps, 4096);
 262             if ($line === false) {
 263                 continue;
 264             }
 265
 266             $dist = self::kanjiStrConv($line, $enc, $kana);
 267             fwrite($fpd, $dist);
 268         }
 269
 270         self::kanjiChangeOrder();
 271         fclose($fps);
 272         fclose($fpd);
 273         unlink($file);
 274
 275         return $tmpfname;
 276     }
 277
 278     /**
 279      * Defines radio form fields to switch between encoding modes
 280      *
 281      * @return string HTML code for the radio controls
 282      */
 283     public static function kanjiEncodingForm(): string
 284     {
 285         $template = new Template();
 286
 287         return $template->render('encoding/kanji_encoding_form');
 288     }
 289
 290     /**
 291      * Lists available encodings.
 292      *
 293      * @return string[]
 294      */
 295     public static function listEncodings(): array
 296     {
 297         if (self::$engine === null) {
 298             self::initEngine();
 299         }
 300
 301         /* Most engines do not support listing */
 302         $config = Config::getInstance();
 303         if (self::$engine != self::ENGINE_MBSTRING) {
 304             return array_filter($config->settings['AvailableCharsets'], static function (string $charset): bool {
 305                 // Removes any ignored character
 306                 $normalizedCharset = strtoupper((string) preg_replace(['/[^A-Za-z0-9\-\/]/'], '', $charset));
 307
 308                 // The character set ISO-2022-CN-EXT can be vulnerable (CVE-2024-2961).
 309                 return ! str_contains($normalizedCharset, 'ISO-2022-CN-EXT')
 310                     && ! str_contains($normalizedCharset, 'ISO2022CNEXT');
 311             });
 312         }
 313
 314         return array_intersect(
 315             array_map(strtolower(...), mb_list_encodings()),
 316             $config->settings['AvailableCharsets'],
 317         );
 318     }
 319 }