{

public const DEFAULT_API_URL = 'https://www.stringencrypt.com/api.php';

private bool $preferCurl = false;

/** When true (default), decompress `source` after successful encrypt+compression responses. */

private bool $decompressEncryptSource = true;

private ?Command $command = null;

/** Activation code sent as `code` (empty = demo). */

private string $apiKey = '';

// —— encrypt ——

private string $label = 'Label';

private ?string $inputString = null;

private ?string $inputBytes = null;

private bool $compression = false;

private Language $language = Language::Php;

/** `false`, or highlight mode string such as `geshi` / `js` when supported server-side. */

private string|bool $highlight = false;

private int $cmdMin = 1;

private int $cmdMax = 3;

private bool $local = false;

private bool $unicode = true;

private string $langLocale = 'en_US.utf8';

private string $ansiEncoding = 'WINDOWS-1250';

private NewLine $newLines = NewLine::Lf;

private ?string $template = null;

private bool $returnTemplate = false;

private bool $includeTags = false;

private bool $includeExample = false;

/** When true, server emits a trace comment block above the encrypted array (hashes, VM JSON). */

private bool $includeDebugComments = false;

public function __construct(

string $apiKey = '',

bool $preferCurl = false,

) {

$this->apiKey = $apiKey;

$this->preferCurl = $preferCurl;

}

/**

public function isDemo(): array|false

{

$previousCommand = $this->command;

$this->setCommand(Command::IsDemo);

$result = $this->send();

$this->command = $previousCommand;

return $result;

}

/**

public function encryptFileContents(string $filePath, string $label): array|false

{

$raw = @file_get_contents($filePath);

if ($raw === false || $raw === '') {

return false;

}

$saved = [

'command' => $this->command,

'inputString' => $this->inputString,

'inputBytes' => $this->inputBytes,

'label' => $this->label,

];

$this->setCommand(Command::Encrypt)->setBytes($raw)->setLabel($label);

$result = $this->send();

$this->command = $saved['command'];

$this->inputString = $saved['inputString'];

$this->inputBytes = $saved['inputBytes'];

$this->label = $saved['label'];

return $result;

}

/**

public function encryptString(string $string, string $label): array|false

{

$saved = [

'command' => $this->command,

'inputString' => $this->inputString,

'inputBytes' => $this->inputBytes,

'label' => $this->label,

];

$this->setCommand(Command::Encrypt)->setString($string)->setLabel($label);

$result = $this->send();

$this->command = $saved['command'];

$this->inputString = $saved['inputString'];

$this->inputBytes = $saved['inputBytes'];

$this->label = $saved['label'];

return $result;

}

public function getPreferCurl(): bool

{

return $this->preferCurl;

}

public function setPreferCurl(bool $preferCurl): self

{

$this->preferCurl = $preferCurl;

return $this;

}

public function getDecompressEncryptSource(): bool

{

return $this->decompressEncryptSource;

}

/**

public function setDecompressEncryptSource(bool $decompressEncryptSource): self

{

$this->decompressEncryptSource = $decompressEncryptSource;

return $this;

}

public function getCommand(): ?Command

{

return $this->command;

}

public function setCommand(Command $command): self

{

$this->command = $command;

return $this;

}

public function getLabel(): string

{

return $this->label;

}

public function setLabel(string $label): self

{

$this->label = $label;

return $this;

}

/** UTF-8 text input; clears raw bytes input. */

public function setString(string $string): self

{

$this->inputString = $string;

$this->inputBytes = null;

return $this;

}

/** Raw binary input; clears string input. */

public function setBytes(string $bytes): self

{

$this->inputBytes = $bytes;

$this->inputString = null;

return $this;

}

public function getCompression(): bool

{

return $this->compression;

}

public function setCompression(bool $compression): self

{

$this->compression = $compression;

return $this;

}

public function getLanguage(): Language

{

return $this->language;

}

public function setLanguage(Language $language): self

{

$this->language = $language;

return $this;

}

public function getHighlight(): string|bool

{

return $this->highlight;

}

public function setHighlight(string|bool $highlight): self

{

$this->highlight = $highlight;

return $this;

}

public function getCmdMin(): int

{

return $this->cmdMin;

}

public function setCmdMin(int $cmdMin): self

{

$this->cmdMin = $cmdMin;

return $this;

}

public function getCmdMax(): int

{

return $this->cmdMax;

}

public function setCmdMax(int $cmdMax): self

{

$this->cmdMax = $cmdMax;

return $this;

}

public function getLocal(): bool

{

return $this->local;

}

public function setLocal(bool $local): self

{

$this->local = $local;

return $this;

}

public function getUnicode(): bool

{

return $this->unicode;

}

public function setUnicode(bool $unicode): self

{

$this->unicode = $unicode;

return $this;

}

public function getLangLocale(): string

{

return $this->langLocale;

}

public function setLangLocale(string $langLocale): self

{

$this->langLocale = $langLocale;

return $this;

}

public function getAnsiEncoding(): string

{

return $this->ansiEncoding;

}

public function setAnsiEncoding(string $ansiEncoding): self

{

$this->ansiEncoding = $ansiEncoding;

return $this;

}

public function getNewLines(): NewLine

{

return $this->newLines;

}

public function setNewLines(NewLine $newLines): self

{

$this->newLines = $newLines;

return $this;

}

public function getTemplate(): ?string

{

return $this->template;

}

public function setTemplate(?string $template): self

{

$this->template = $template;

return $this;

}

public function getReturnTemplate(): bool

{

return $this->returnTemplate;

}

public function setReturnTemplate(bool $returnTemplate): self

{

$this->returnTemplate = $returnTemplate;

return $this;

}

public function getIncludeTags(): bool

{

return $this->includeTags;

}

public function setIncludeTags(bool $includeTags): self

{

$this->includeTags = $includeTags;

return $this;

}

public function getIncludeExample(): bool

{

return $this->includeExample;

}

public function setIncludeExample(bool $includeExample): self

{

$this->includeExample = $includeExample;

return $this;

}

public function getIncludeDebugComments(): bool

{

return $this->includeDebugComments;

}

public function setIncludeDebugComments(bool $includeDebugComments): self

{

$this->includeDebugComments = $includeDebugComments;

return $this;

}

/**

public function reset(): self

{

$this->command = null;

$this->label = '$label';

$this->inputString = null;

$this->inputBytes = null;

$this->compression = false;

$this->language = Language::Php;

$this->highlight = false;

$this->cmdMin = 1;

$this->cmdMax = 3;

$this->local = false;

$this->unicode = true;

$this->langLocale = 'en_US.utf8';

$this->ansiEncoding = 'WINDOWS-1250';

$this->newLines = NewLine::Lf;

$this->template = null;

$this->returnTemplate = false;

$this->includeTags = false;

$this->includeExample = false;

$this->includeDebugComments = false;

return $this;

}

/**

public function toRequestArray(): array

{

if ($this->command === null) {

throw new InvalidArgumentException('Command must be set (use setCommand()).');

}

return match ($this->command) {

Command::Info => $this->buildInfoParams(),

Command::IsDemo => $this->buildIsDemoParams(),

Command::Encrypt => $this->buildEncryptParams(),

};

}

/**

public function send(?bool $useCurl = null): array|false

{

$useCurl = $useCurl ?? $this->preferCurl;

if ($useCurl && !function_exists('curl_init')) {

$useCurl = false;

}

$params = $this->toRequestArray();

$raw = $useCurl

? $this->postWithCurl(self::DEFAULT_API_URL, $params)

: $this->postWithStreams(self::DEFAULT_API_URL, $params);

if ($raw === false || $raw === '') {

return false;

}

$decoded = json_decode($raw, true);

if (!is_array($decoded)) {

return false;

}

return $this->applyDecryptorSourceDecompression($decoded);

}

/**

private function applyDecryptorSourceDecompression(array $response): array

{

if ($this->command !== Command::Encrypt || !$this->compression || !$this->decompressEncryptSource) {

return $response;

}

if (($response['error'] ?? null) !== ErrorCode::SUCCESS) {

return $response;

}

if (!isset($response['source']) || !is_string($response['source'])) {

return $response;

}

$binary = base64_decode($response['source'], true);

if ($binary === false) {

return $response;

}

$plain = gzuncompress($binary);

if ($plain === false) {

return $response;

}

$response['source'] = $plain;

return $response;

}

/**

private function buildInfoParams(): array

{

return [

'command' => Command::Info->value,

'code' => $this->apiKey,

];

}

/**

private function buildIsDemoParams(): array

{

return [

'command' => Command::IsDemo->value,

'code' => $this->apiKey,

];

}

/**

private function buildEncryptParams(): array

{

$p = [

'command' => Command::Encrypt->value,

'code' => $this->apiKey,

'label' => $this->label,

'compression' => $this->compression,

'lang' => $this->language->value,

'cmd_min' => $this->cmdMin,

'cmd_max' => $this->cmdMax,

'local' => $this->local,

'unicode' => $this->unicode,

'lang_locale' => $this->langLocale,

'ansi_encoding' => $this->ansiEncoding,

'new_lines' => $this->newLines->value,

'return_template' => $this->returnTemplate,

'include_tags' => $this->includeTags,

'include_example' => $this->includeExample,

'include_debug_comments' => $this->includeDebugComments,

];

if ($this->inputString !== null) {

$p['string'] = $this->inputString;

} elseif ($this->inputBytes !== null) {

$p['bytes'] = $this->inputBytes;

}

if ($this->highlight !== false) {

$p['highlight'] = $this->highlight;

}

if ($this->template !== null) {

$p['template'] = $this->template;

}

return $p;

}

/**

private function postWithStreams(string $url, array $data): string|false

{

$body = http_build_query($data);

$params = [

'http' => [

'method' => 'POST',

'header' => "Content-Type: application/x-www-form-urlencoded\r\n",

'content' => $body,

],

];

$ctx = stream_context_create($params);

$fp = @fopen($url, 'rb', false, $ctx);

if ($fp === false) {

return false;

}

try {

$response = stream_get_contents($fp);

} finally {

fclose($fp);

}

return $response !== false ? $response : false;

}

/**

private function postWithCurl(string $url, array $data): string|false

{

$ch = curl_init($url);

if ($ch === false) {

return false;

}

$body = http_build_query($data);

curl_setopt_array($ch, [

CURLOPT_POST => true,

CURLOPT_POSTFIELDS => $body,

CURLOPT_RETURNTRANSFER => true,

CURLOPT_USERAGENT => 'pelock/stringencrypt (+https://www.stringencrypt.com)',

CURLOPT_HTTPHEADER => ['Content-Type: application/x-www-form-urlencoded'],

]);

$result = curl_exec($ch);

curl_close($ch);

return $result !== false ? $result : false;

}