Steganografia Kodek Online Dokumentacja Web API SDK

Zautomatyzuj ukrywanie sekretnych danych w obrazkach i zdjęciach z użyciem pakietów Web API SDK Steganografia Kodek Online (Python, JavaScript, Rust, C#, Go, Java, PHP, PowerShell i Ruby).

Opis

Możesz skorzystać ze wszystkich funkcji Steganografia Kodek Online poprzez nasz interfejs Web API. Interfejs Web API bazuje na zapytaniu POST i zwraca wynik zakodowany jako JSON.

Te same funkcje są dostępne także przez interfejs REST. GET /api/steganography-online-codec/v1/license sprawdza klucz aktywacyjny. POST /api/steganography-online-codec/v1/encode ukrywa wiadomość w obrazie. POST /api/steganography-online-codec/v1/decode odczytuje ją z powrotem. Klucz przekaż w nagłówku Authorization: Bearer albo X-Api-Key. Obraz wyślij jako część multipart o nazwie file, a message i password jako pola formularza. Udane kodowanie zwraca encoded.png. Udane dekodowanie zwraca message.bin. Status i dane licencji są w nagłówku X-PELock-Result.

Instalacja

Dla szybszego wdrożenia możesz zainstalować pakiety SDK poprzez popularne repozytoria bibliotek (PyPI, npm, crates.io, NuGet, pkg.go.dev, Maven, Packagist, PowerShell Gallery, RubyGems). Kody źródłowe są także dostępne na GitHubie:

Repozytorium Język Instalacja Pakiet Źródła
Repozytorium PyPI dla Pythona Python pip install steganography-online-codec PyPI GitHub
Język programowania JavaScript JavaScript

Run

npm i steganography-online-codec

lub dodaj do sekcji dependencies w pliku konfiguracyjnym package.json wpis:

"dependencies": {
"steganography-online-codec": "latest"
},

npm GitHub
Repozytorium Crates.io dla Rust Rust

Uruchom:

cargo add steganography-online-codec

lub dodaj w pliku Cargo.toml w sekcji [dependencies] wpis:

steganography-online-codec = "1"
Crates GitHub
Repozytorium NuGet C#

Uruchom:

dotnet add package SteganographyOnlineCodec

lub dodaj w pliku .csproj:

<PackageReference
Include="SteganographyOnlineCodec"
Version="1.0.1" />
NuGet GitHub
Pakiety modułów Go Go

Uruchom:

go get github.com/PELock/Steganography-Online-Codec-Go

lub dodaj poniższy wpis do pliku go.mod

require github.com/PELock/Steganography-Online-Codec-Go v1.0.2
Go GitHub
Centralne Repozytorium Maven Java Dodaj tę zależność do pliku pom.xml
<dependency>
  <groupId>com.pelock</groupId>
  <artifactId>steganography-online-codec</artifactId>
  <version>1.0.2</version>
</dependency>
Maven GitHub
Repozytorium Packagist dla Composera PHP

Uruchom:

php composer.phar require --prefer-dist pelock/steganography-online-codec "*"

lub dodaj do sekcji require w pliku konfiguracyjnym composer.json wpis:

"pelock/steganography-online-codec": "*"
Packagist GitHub
PowerShell Gallery PowerShell

Uruchom:

Install-Module -Name SteganographyOnlineCodec

lub:

Install-PSResource -Name SteganographyOnlineCodec

PowerShell Gallery GitHub
Repozytorium RubyGems Ruby

Uruchom:

gem install steganography-online-codec

lub dodaj poniższy wpis do pliku Gemfile

gem "steganography-online-codec"
RubyGems GitHub

Przykłady użycia

Ukrywanie zaszyfrowanej wiadomości w pliku obrazka

#!/usr/bin/env python

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# Ten przykład pokazuje, jak ukryć zaszyfrowaną tajną wiadomość w pliku graficznym.
#
# Wersja      : v1.00
# Język     : Python
# Autor       : Bartosz Wójcik
# Projekt      : https://www.pelock.com/products/steganography-online-codec
# Strona       : https://www.pelock.com
#
###############################################################################

#
# include Steganography Online Codec module
#
from steganography_online_codec import *

#
# utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
#
mySteganographyOnlineCodec = SteganographyOnlineCodec("YOUR-WEB-API-KEY")

#
# zakoduj ukrytą wiadomość (zaszyfrowaną hasłem) w pliku graficznym
#
result = mySteganographyOnlineCodec.encode("input_file.jpg", "Secret message", "Pa$$word", "output_file_with_hidden_secret_message.png")

#
# tablica result[] zawiera wyniki kodowania oraz dodatkowe informacje
#
if result and "error" in result:
    if result["error"] == Errors.SUCCESS:
        print(f'Tajna wiadomość zakodowana i zapisana do the output PNG file.')
    else:
        print(f'Kod błędu {result["error"]}')
else:
    print("Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.")
"use strict";

/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ten przykład pokazuje, jak ukryć zaszyfrowaną tajną wiadomość w pliku graficznym.
 *
 * Wersja      : v1.00
 * Język     : JavaScript
 * Autor        : Bartosz Wójcik (oryginalny przykład)
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
/*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';

// utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// zakoduj ukrytą wiadomość (zaszyfrowaną hasłem) w pliku graficznym
(async () => {

	const inputFile = 'input_file.jpg';
	const secretMessage = 'Secret message';
	const password = 'Pa$$word';
	const outputFile = 'output_file_with_hidden_secret_message.png';

	try {
		const result = await mySteganographyOnlineCodec.encode(inputFile, secretMessage, password, outputFile);

		// obiekt result zawiera wyniki kodowania oraz dodatkowe informacje
		console.log('Tajna wiadomość zakodowana i zapisana do the output PNG file.');
	} catch (err) {
		console.error('Encoding failed:', err.error_message || err.message || String(err));
	}
})();
// Przykład: ukrycie zaszyfrowanej tajnej wiadomości w obrazie przez Web API.

use steganography_online_codec::SteganographyOnlineCodec;

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    let input_file = "input_file.jpg";
    let secret_message = "Secret message";
    let password = "Pa$$word";
    let output_file = "output_file_with_hidden_secret_message.png";

    match my_steganography_online_codec
        .encode(input_file, secret_message, password, output_file)
        .await
    {
        Ok(_result) => {
            println!("Tajna wiadomość zakodowana i zapisana do the output PNG file.");
        }
        Err(err) => {
            eprintln!("Encoding failed: {}", err.error_message());
        }
    }
}
/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ten przykład pokazuje, jak ukryć zaszyfrowaną tajną wiadomość w pliku graficznym.
 *
 * Wersja      : v1.00
 * Język     : C#
 * Autor        : Bartosz Wójcik (oryginalny przykład)
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;
// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// utwórz instancję klasy Steganography Online Codec (placeholder klucza aktywacyjnego)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// zakoduj ukrytą wiadomość (zaszyfrowaną hasłem) w pliku graficznym
const string InputFile = "input_file.jpg";
const string SecretMessage = "Secret message";
const string Password = "Pa$$word";
const string OutputFile = "output_file_with_hidden_secret_message.png";

try
{
	await codec.EncodeAsync(InputFile, SecretMessage, Password, OutputFile).ConfigureAwait(false);

	// EncodeResult udostępnia dane licencji, gdy są dostępne.
	Console.WriteLine("Tajna wiadomość zakodowana i zapisana do the output PNG file.");
}
catch (SteganographyApiException err)
{
	Console.Error.WriteLine("Encoding failed: " + (!string.IsNullOrEmpty(err.Message)
		? err.Message
		: $"Kod błędu {err.Error}"));
}
/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ten przykład pokazuje, jak ukryć zaszyfrowaną tajną wiadomość w pliku graficznym.
 *
 * Wersja        : v1.0.2
 * Język       : Go
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	steganographyonlinecodec "github.com/PELock/Steganography-Online-Codec-Go"
)

func main() {
	client := steganographyonlinecodec.New("YOUR-WEB-API-KEY")
	result, err := client.Encode(context.Background(), "input_file.jpg", "Secret message", "Pa$$word", "output_file_with_hidden_secret_message.png")
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if result.Error == steganographyonlinecodec.ErrorSuccess {
		fmt.Println("Tajna wiadomość zakodowana i zapisana do the output PNG file.")
		return
	}
	fmt.Printf("Kod błędu %d\n", result.Error)
}
/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ten przykład pokazuje, jak ukryć zaszyfrowaną tajną wiadomość w pliku graficznym.
 *
 * Wersja        : v1.0.2
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.fasterxml.jackson.databind.JsonNode;
import com.pelock.steganography.Errors;
import com.pelock.steganography.SteganographyOnlineCodec;

public class SteganographySimpleExample {

  public static void main(String[] args) throws Exception {
    SteganographyOnlineCodec client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");
    JsonNode result =
        client.encode(
            "input_file.jpg",
            "Secret message",
            "Pa$$word",
            "output_file_with_hidden_secret_message.png");

    if (result != null && result.has("error")) {
      if (result.get("error").asInt() == Errors.SUCCESS) {
        System.out.println("Tajna wiadomość zakodowana i zapisana do the output PNG file.");
      } else {
        System.out.println("Kod błędu " + result.get("error").asInt());
      }
    } else {
      System.out.println("Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.");
    }
  }
}
<?php

declare(strict_types=1);

use PELock\SteganographyOnlineCodec\Errors;
use PELock\SteganographyOnlineCodec\SteganographyOnlineCodec;

require __DIR__ . "/vendor/autoload.php";

$client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");
$result = $client->encode("input_file.jpg", "Secret message", "Pa$$word", "output_file_with_hidden_secret_message.png");

if ($result && array_key_exists("error", $result)) {
    if ($result["error"] === Errors::SUCCESS) {
        echo "Tajna wiadomość zakodowana i zapisana do the output PNG file.\n";
    } else {
        echo "Kod błędu {$result["error"]}\n";
    }
} else {
    echo "Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.\n";
}
################################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# Zakoduj tajną wiadomość w obrazie.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module SteganographyOnlineCodec

$client = New-SteganographyOnlineCodec -ApiKey 'YOUR-WEB-API-KEY'
$result = $client.Encode('input_file.jpg', 'Secret message', 'Pa$$word', 'output_file_with_hidden_secret_message.png')

if ($result -and $result.ContainsKey('error')) {
    if ($result.error -eq [SteganographyErrors]::SUCCESS) {
        Write-Host 'Tajna wiadomość zakodowana i zapisana do the output PNG file.'
    }
    else {
        Write-Host ("Kod błędu {0}" -f $result.error)
    }
}
else {
    Write-Host 'Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.'
}
# frozen_string_literal: true

###############################################################################
#
# Steganography Online Codec — ukrycie zaszyfrowanej wiadomości
#
# Wersja        : v1.0.2
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "steganography-online-codec"

client = SteganographyOnlineCodec.new("YOUR-WEB-API-KEY")
result = client.encode("input_file.jpg", "Secret message", "Pa$$word", "output_file_with_hidden_secret_message.png")

if result && result["error"] == SteganographyOnlineCodec::Errors::SUCCESS
  puts "Tajna wiadomość zakodowana i zapisana do the output PNG file."
elsif result
  warn "Kod błędu: #{result["error"]}"
else
  warn "Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego."
end
#!/usr/bin/env bash

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu REST.
#
# W tym przykładzie ukryjemy zaszyfrowaną wiadomość w pliku graficznym.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"
#
# ukryj wiadomość w obrazie
#
# response body    - encoded PNG, saved as encoded.png
# X-PELock-Result  - status JSON obok obrazu
#
# nieudane kodowanie to HTTP 422 i treść JSON zamiast obrazu
curl -sS -D - -o encoded.png \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@input_file.jpg" \
  -F "message=Secret message" \
  -F 'password=Pa$$word' \
  "https://www.pelock.com/api/steganography-online-codec/v1/encode"

Wydobycie ukrytej, sekretnej wiadomości z zakodowanego obrazka

#!/usr/bin/env python

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# W tym przykładzie zobaczymy, jak odczytać wcześniej zaszyfrowaną i ukrytą
# tajną wiadomość z pliku graficznego.
#
# Wersja      : v1.00
# Język     : Python
# Autor       : Bartosz Wójcik
# Projekt      : https://www.pelock.com/products/steganography-online-codec
# Strona       : https://www.pelock.com
#
###############################################################################

#
# include Steganography Online Codec module
#
from steganography_online_codec import *

#
# jeśli nie chcesz używać modułu Pythona, możesz zaimportować go bezpośrednio z pliku
#
#from pelock.steganography_online_codec import *


#
# utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
#
mySteganographyOnlineCodec = SteganographyOnlineCodec("YOUR-WEB-API-KEY")

#
# odczytaj ukrytą wiadomość z wcześniej zakodowanego pliku graficznego
#

# w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
# obsługiwany format obrazu to PNG i tylko PNG!
input_file_path = "output_file_with_hidden_secret_message.png"

# w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
password = "Pa$$word"

# odczytaj ukrytą wiadomość z obrazu (tylko pliki PNG)
result = mySteganographyOnlineCodec.decode(input_file_path, password)

#
# słownik result[] zawiera wyniki dekodowania oraz dodatkowe informacje
#
if result and "error" in result:

    print(f'Działasz w wersji {"pełnej" if result["license"]["activationStatus"] is True else "demonstracyjnej"}')

    if result["error"] == Errors.SUCCESS:
        print(f'Secret message is "{result["message"]}"')
        print(f'Pozostała liczba kredytów użycia - {result["license"]["usagesCount"]}')
    elif result["error"] == Errors.INVALID_INPUT:
        print(f'Nieprawidłowy plik wejściowy {input_file_path} albo plik nie istnieje')
    elif result["error"] == Errors.IMAGE_TOO_BIG:
        print(f'Image file is too big, current limit is set to {mySteganographyOnlineCodec.convert_size(result["limits"]["maxFileSize"])}')
    elif result["error"] == Errors.LIMIT_MESSAGE:
        print(f'Extracted message is too long, current limit is set to {result["limits"]["maxMessageLen"]}')
    elif result["error"] == Errors.LIMIT_PASSWORD:
        print(f'Hasło jest za długie, bieżący limit to {result["limits"]["maxPasswordLen"]}')
    elif result["error"] == Errors.INVALID_PASSWORD:
        print(f'Nieprawidłowe hasło')
    else:
        print(f'Wystąpił nieznany błąd, kod błędu: {result["error"]}')
else:
    print("Podczas odczytywania tajnej wiadomości wydarzyło się coś nieoczekiwanego.")
"use strict";

/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie zobaczymy, jak odczytać wcześniej zaszyfrowaną i ukrytą
 * tajną wiadomość z pliku graficznego.
 *
 * Wersja      : v1.00
 * Język     : JavaScript
 * Autor       : Bartosz Wójcik
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
 /*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';

// utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// odczytaj ukrytą wiadomość z wcześniej zakodowanego pliku graficznego
(async () => {
	// w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
	// obsługiwany format obrazu to PNG i tylko PNG!
	const inputFilePath = 'output_file_with_hidden_secret_message.png';

	// w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
	const password = 'Pa$$word';

	try {
		// odczytaj ukrytą wiadomość z obrazu (tylko pliki PNG)
		const result = await mySteganographyOnlineCodec.decode(inputFilePath, password);

		// obiekt result zawiera wyniki dekodowania oraz dodatkowe informacje
		console.log(`Działasz w wersji ${result.license?.activationStatus ? 'pełnej' : 'demonstracyjnej'}`);

		console.log(`Secret message is "${result.message}"`);

		if (result.license && result.license.usagesCount !== undefined) {
			console.log(`Pozostała liczba kredytów użycia - ${result.license.usagesCount}`);
		}
	} catch (err) {
		switch (err.error) {
			case Errors.INVALID_INPUT:
				console.log(`Nieprawidłowy plik wejściowy ${inputFilePath} albo plik nie istnieje`);
				break;
			case Errors.IMAGE_TOO_BIG:
				console.log(`Image file is too big, current limit is set to ${err.raw?.limits?.maxFileSize ?? 'unknown'}`);
				break;
			case Errors.LIMIT_MESSAGE:
				console.log(`Extracted message is too long, current limit is set to ${err.raw?.limits?.maxMessageLen ?? 'unknown'}`);
				break;
			case Errors.LIMIT_PASSWORD:
				console.log(`Hasło jest za długie, bieżący limit to ${err.raw?.limits?.maxPasswordLen ?? 'unknown'}`);
				break;
			case Errors.INVALID_PASSWORD:
				console.log('Nieprawidłowe hasło');
				break;
			default:
				console.log(`Wystąpił błąd: ${err.error_message ?? String(err)}`);
		}
	}
})();
// Przykład: dekodowanie (odczyt) ukrytej wiadomości z PNG.

use steganography_online_codec::{errors, SteganographyOnlineCodec};

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    // w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
    // obsługiwany format obrazu to PNG i tylko PNG!
    let input_file_path = "output_file_with_hidden_secret_message.png";

    // w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
    let password = "Pa$$word";

    match my_steganography_online_codec
        .decode(input_file_path, password)
        .await
    {
        Ok(result) => {
            let full = result
                .license
                .as_ref()
                .and_then(|l| l.activation_status)
                .unwrap_or(false);
            println!(
                "Działasz w wersji {}",
                if full { "full" } else { "demo" }
            );

            let msg = result.message.as_deref().unwrap_or("");
            println!("Secret message is \"{msg}\"");

            if let Some(ref lic) = result.license {
                if let Some(c) = lic.usages_count {
                    println!("Pozostała liczba kredytów użycia - {c}");
                }
            }
        }
        Err(err) => match err.code() {
            errors::INVALID_INPUT => {
                println!(
                    "Nieprawidłowy plik wejściowy {} albo plik nie istnieje",
                    input_file_path
                );
            }
            errors::IMAGE_TOO_BIG => {
                let lim = err
                    .raw()
                    .and_then(|j| j.get("limits"))
                    .and_then(|l| l.get("maxFileSize"))
                    .map(|v| v.to_string())
                    .unwrap_or_else(|| "unknown".to_string());
                println!("Image file is too big, current limit is set to {lim}");
            }
            errors::LIMIT_MESSAGE => {
                let lim = err
                    .raw()
                    .and_then(|j| j.get("limits"))
                    .and_then(|l| l.get("maxMessageLen"))
                    .map(|v| v.to_string())
                    .unwrap_or_else(|| "unknown".to_string());
                println!(
                    "Extracted message is too long, current limit is set to {lim}"
                );
            }
            errors::LIMIT_PASSWORD => {
                let lim = err
                    .raw()
                    .and_then(|j| j.get("limits"))
                    .and_then(|l| l.get("maxPasswordLen"))
                    .map(|v| v.to_string())
                    .unwrap_or_else(|| "unknown".to_string());
                println!("Hasło jest za długie, bieżący limit to {lim}");
            }
            errors::INVALID_PASSWORD => {
                println!("Nieprawidłowe hasło");
            }
            _ => {
                println!("Wystąpił błąd: {}", err.error_message());
            }
        },
    }
}
/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie zobaczymy, jak odczytać wcześniej zaszyfrowaną i ukrytą
 * tajną wiadomość z pliku graficznego.
 *
 * Wersja      : v1.00
 * Język     : C#
 * Autor       : Bartosz Wójcik
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using System.Text.Json;
using PELock;

// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// utwórz instancję klasy Steganography Online Codec (placeholder klucza aktywacyjnego)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// odczytaj ukrytą wiadomość z wcześniej zakodowanego pliku graficznego
// w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
// obsługiwany format obrazu to PNG i tylko PNG!
string inputFilePath = "output_file_with_hidden_secret_message.png";

// w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
const string Password = "Pa$$word";

try
{
	// odczytaj ukrytą wiadomość z obrazu (tylko pliki PNG)
	DecodeResult result =
		await codec.DecodeAsync(inputFilePath, Password).ConfigureAwait(false);

	string runningVersion = result.License?.ActivationStatus == true ? "full" : "demo";

	Console.WriteLine($"Działasz w wersji {runningVersion}");

	Console.WriteLine($"Secret message is \"{result.Message}\"");

	if (result.License?.UsagesCount.HasValue ?? false)
		Console.WriteLine($"Pozostała liczba kredytów użycia - {result.License!.UsagesCount}");
}
catch (SteganographyApiException err)
{
	switch (err.Error)
	{
	case Errors.InvalidInput:
		Console.WriteLine($"Nieprawidłowy plik wejściowy {inputFilePath} albo plik nie istnieje");
		break;
	case Errors.ImageTooBig:
		Console.WriteLine($"Image file is too big, current limit is set to {ReadLimitDecode(err.Raw, "maxFileSize")}");
		break;
	case Errors.LimitMessage:
		Console.WriteLine($"Extracted message is too long, current limit is set to {ReadLimitDecode(err.Raw, "maxMessageLen")}");
		break;
	case Errors.LimitPassword:
		Console.WriteLine($"Hasło jest za długie, bieżący limit to {ReadLimitDecode(err.Raw, "maxPasswordLen")}");
		break;
	case Errors.InvalidPassword:
		Console.WriteLine("Nieprawidłowe hasło");
		break;
	default:
		Console.WriteLine($"Wystąpił błąd: {(string.IsNullOrEmpty(err.Message) ? $"Błąd API code {err.Error}" : err.Message)}");
		break;
	}
}

static string ReadLimitDecode(JsonElement? payload, string key)
{
	if (payload.HasValue &&
		payload.Value.TryGetProperty("limits", out JsonElement limits) &&
		limits.TryGetProperty(key, out JsonElement probe) &&
		probe.ValueKind == JsonValueKind.Number &&
		probe.TryGetInt64(out long value))
	{
		return value.ToString();
	}

	return "unknown";
}

/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ten przykład pokazuje, jak odczytać wcześniej zaszyfrowaną tajną wiadomość.
 *
 * Wersja        : v1.0.2
 * Język       : Go
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	steganographyonlinecodec "github.com/PELock/Steganography-Online-Codec-Go"
)

func main() {
	client := steganographyonlinecodec.New("YOUR-WEB-API-KEY")
	result, err := client.Decode(context.Background(), "output_file_with_hidden_secret_message.png", "Pa$$word")
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if result.Error != steganographyonlinecodec.ErrorSuccess {
		fmt.Printf("Kod błędu %d\n", result.Error)
		os.Exit(1)
	}
	fmt.Println(result.Message)
}
/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ten przykład pokazuje, jak odczytać wcześniej zaszyfrowaną tajną wiadomość.
 *
 * Wersja        : v1.0.2
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.fasterxml.jackson.databind.JsonNode;
import com.pelock.steganography.Errors;
import com.pelock.steganography.SteganographyOnlineCodec;

public class SteganographyExtractExample {

  public static void main(String[] args) throws Exception {
    SteganographyOnlineCodec client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");
    JsonNode result = client.decode("output_file_with_hidden_secret_message.png", "Pa$$word");

    if (result != null && result.has("error")) {
      if (result.get("error").asInt() == Errors.SUCCESS) {
        System.out.println("Secret message is \"" + result.path("message").asText() + "\"");
      } else {
        System.out.println("Kod błędu " + result.get("error").asInt());
      }
    } else {
      System.out.println("Podczas odczytywania tajnej wiadomości wydarzyło się coś nieoczekiwanego.");
    }
  }
}
<?php

declare(strict_types=1);

use PELock\SteganographyOnlineCodec\Errors;
use PELock\SteganographyOnlineCodec\SteganographyOnlineCodec;

require __DIR__ . "/vendor/autoload.php";

$client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");
$result = $client->decode("output_file_with_hidden_secret_message.png", "Pa$$word");

if ($result && array_key_exists("error", $result)) {
    if ($result["error"] === Errors::SUCCESS) {
        echo "Secret message is \"{$result["message"]}\"\n";
    } else {
        echo "Kod błędu {$result["error"]}\n";
    }
} else {
    echo "Podczas odczytywania tajnej wiadomości wydarzyło się coś nieoczekiwanego.\n";
}
################################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# Odczytaj tajną wiadomość z obrazu.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module SteganographyOnlineCodec

$client = New-SteganographyOnlineCodec -ApiKey 'YOUR-WEB-API-KEY'
$result = $client.Decode('output_file_with_hidden_secret_message.png', 'Pa$$word')

if ($result -and $result.ContainsKey('error')) {
    if ($result.error -eq [SteganographyErrors]::SUCCESS) {
        Write-Host ("Secret message is `"{0}`"" -f $result.message)
    }
    else {
        Write-Host ("Kod błędu {0}" -f $result.error)
    }
}
else {
    Write-Host 'Podczas odczytywania tajnej wiadomości wydarzyło się coś nieoczekiwanego.'
}
# frozen_string_literal: true

###############################################################################
#
# Steganography Online Codec — odczyt ukrytej wiadomości
#
# Wersja        : v1.0.2
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "steganography-online-codec"

client = SteganographyOnlineCodec.new("YOUR-WEB-API-KEY")
result = client.decode("output_file_with_hidden_secret_message.png", "Pa$$word")

if result && result["error"] == SteganographyOnlineCodec::Errors::SUCCESS
  puts "Secret message is \"#{result["message"]}\""
elsif result
  warn "Kod błędu: #{result["error"]}"
else
  warn "Podczas odczytywania tajnej wiadomości wydarzyło się coś nieoczekiwanego."
end
#!/usr/bin/env bash

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu REST.
#
# W tym przykładzie odczytamy ukrytą wiadomość z zakodowanego obrazu.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"
#
# odczytaj ukrytą wiadomość
#
# response body    - bajty wiadomości, zapisane jako message.bin
# X-PELock-Result  - status JSON obok wiadomości
#
# nieudane dekodowanie to HTTP 422 i treść JSON zamiast wiadomości
#
curl -sS -D - -o message.bin \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@output_file_with_hidden_secret_message.png" \
  -F 'password=Pa$$word' \
  "https://www.pelock.com/api/steganography-online-codec/v1/decode"

Ukrycie sekretnej wiadomości w zdjęciu (rozszerzona obsługa błędów)

#!/usr/bin/env python

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# W tym przykładzie zobaczymy, jak ukryć zaszyfrowaną wiadomość w
# pliku graficznego przy użyciu naszego kodeka.
#
# Wersja      : v1.00
# Język     : Python
# Autor       : Bartosz Wójcik
# Projekt      : https://www.pelock.com/products/steganography-online-codec
# Strona       : https://www.pelock.com
#
###############################################################################

#
# include Steganography Online Codec module
#
from steganography_online_codec import *

#
# jeśli nie chcesz używać modułu Pythona, możesz zaimportować go bezpośrednio z pliku
#
#from pelock.steganography_online_codec import *

#
# utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
#
mySteganographyOnlineCodec = SteganographyOnlineCodec("YOUR-WEB-API-KEY")

#
# zakoduj ukrytą wiadomość w źródłowym pliku graficznym
#

# w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
# obsługiwane formaty obrazów to PNG, JPG, GIF, BMP, WBMP, GD2, AVIF, WEBP (napisz, jeśli potrzebujesz więcej)
input_file_path = "input_file.webp"

# w pełnej wersji rozmiar wiadomości jest nieograniczony (demo: maks. 16 znaków)
secret_message = "Secret message"

# w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
password = "Pa$$word"

# gdzie zapisać zakodowany obraz z tajną wiadomością
output_file_path = "output_file_with_hidden_secret_message.png"

# zakoduj ukrytą wiadomość (zaszyfrowaną hasłem) w pliku graficznym
result = mySteganographyOnlineCodec.encode(input_file_path, secret_message, password, output_file_path)

#
# tablica result[] zawiera wyniki kodowania oraz dodatkowe informacje
#
if result and "error" in result:

    print(f'Działasz w wersji {"pełnej" if result["license"]["activationStatus"] is True else "demonstracyjnej"}')

    if result["error"] == Errors.SUCCESS:
        print(f'Tajna wiadomość zakodowana i zapisana do {output_file_path}')
        print(f'Pozostała liczba kredytów użycia - {result["license"]["usagesCount"]}')
    elif result["error"] == Errors.INVALID_INPUT:
        print(f'Nieprawidłowy plik wejściowy {input_file_path} albo plik nie istnieje')
    elif result["error"] == Errors.MESSAGE_TOO_LONG:
        print(f'Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku')
    elif result["error"] == Errors.IMAGE_TOO_BIG:
        print(f'Image file is too big, current limit is set to {mySteganographyOnlineCodec.convert_size(result["limits"]["maxFileSize"])}')
    elif result["error"] == Errors.LIMIT_MESSAGE:
        print(f'Message is too long, current limit is set to {result["limits"]["maxMessageLen"]}')
    elif result["error"] == Errors.LIMIT_PASSWORD:
        print(f'Hasło jest za długie, bieżący limit to {result["limits"]["maxPasswordLen"]}')
    elif result["error"] == Errors.INVALID_PASSWORD:
        print(f'Nieprawidłowe hasło')
    else:
        print(f'Wystąpił nieznany błąd, kod błędu: {result["error"]}')
else:
    print("Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.")
"use strict";

/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie zobaczymy, jak ukryć zaszyfrowaną wiadomość w
 * pliku graficznego przy użyciu naszego kodeka.
 *
 * Wersja      : v1.00
 * Język     : JavaScript
 * Autor       : Bartosz Wójcik
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
 /*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';


// utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// zakoduj ukrytą wiadomość w źródłowym pliku graficznym
(async () => {
	// w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
	// obsługiwane formaty obrazów to PNG, JPG, GIF, BMP, WBMP, GD2, AVIF, WEBP (napisz, jeśli potrzebujesz więcej)
	const inputFilePath = 'input_file.webp';

	// w pełnej wersji rozmiar wiadomości jest nieograniczony (demo: maks. 16 znaków)
	const secretMessage = 'Secret message';

	// w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
	const password = 'Pa$$word';

	// gdzie zapisać zakodowany obraz z tajną wiadomością
	const outputFilePath = 'output_file_with_hidden_secret_message.png';

	try {
		// zakoduj ukrytą wiadomość (zaszyfrowaną hasłem) w pliku graficznym
		const result = await mySteganographyOnlineCodec.encode(inputFilePath, secretMessage, password, outputFilePath);

		// obiekt result zawiera wyniki kodowania oraz dodatkowe informacje
		const versionType = result.license && result.license.activationStatus ? 'full' : 'demo';
		console.log(`Działasz w wersji ${versionType}`);

		console.log(`Tajna wiadomość zakodowana i zapisana do ${outputFilePath}`);
		if (result.license && result.license.usagesCount !== undefined) {
			console.log(`Pozostała liczba kredytów użycia - ${result.license.usagesCount}`);
		}
	} catch (err) {
		const errorCode = err.error;

		switch (errorCode) {
			case Errors.INVALID_INPUT:
				console.log(`Nieprawidłowy plik wejściowy ${inputFilePath} albo plik nie istnieje`);
				break;
			case Errors.MESSAGE_TOO_LONG:
				console.log('Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku');
				break;
			case Errors.IMAGE_TOO_BIG:
				console.log(`Image file is too big, current limit is set to ${err.raw?.limits?.maxFileSize ?? 'unknown'}`);
				break;
			case Errors.LIMIT_MESSAGE:
				console.log(`Message is too long, current limit is set to ${err.raw?.limits?.maxMessageLen ?? 'unknown'}`);
				break;
			case Errors.LIMIT_PASSWORD:
				console.log(`Hasło jest za długie, bieżący limit to ${err.raw?.limits?.maxPasswordLen ?? 'unknown'}`);
				break;
			case Errors.INVALID_PASSWORD:
				console.log('Nieprawidłowe hasło');
				break;
			default:
				console.log(`Wystąpił błąd: ${err.error_message ?? `Kod błędu ${errorCode}`}`);
		}
	}
})();
// Przykład: kodowanie z obsługą kodu błędu (limity demo i pełnej wersji).

use steganography_online_codec::{errors, SteganographyOnlineCodec};

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    // w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
    // obsługiwane formaty obrazów to PNG, JPG, GIF, BMP, WBMP, GD2, AVIF, WEBP (napisz, jeśli potrzebujesz więcej)
    let input_file_path = "input_file.webp";

    // w pełnej wersji rozmiar wiadomości jest nieograniczony (demo: maks. 16 znaków)
    let secret_message = "Secret message";

    // w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
    let password = "Pa$$word";

    // gdzie zapisać zakodowany obraz z tajną wiadomością
    let output_file_path = "output_file_with_hidden_secret_message.png";

    match my_steganography_online_codec
        .encode(
            input_file_path,
            secret_message,
            password,
            output_file_path,
        )
        .await
    {
        Ok(result) => {
            let version_type = result
                .license
                .as_ref()
                .and_then(|l| l.activation_status)
                .unwrap_or(false);
            println!(
                "Działasz w wersji {}",
                if version_type { "full" } else { "demo" }
            );

            println!(
                "Tajna wiadomość zakodowana i zapisana do {}",
                output_file_path
            );
            if let Some(ref lic) = result.license {
                if let Some(c) = lic.usages_count {
                    println!("Pozostała liczba kredytów użycia - {c}");
                }
            }
        }
        Err(err) => {
            let error_code = err.code();
            match error_code {
                errors::INVALID_INPUT => {
                    println!(
                        "Nieprawidłowy plik wejściowy {} albo plik nie istnieje",
                        input_file_path
                    );
                }
                errors::MESSAGE_TOO_LONG => {
                    println!(
                        "Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku"
                    );
                }
                errors::IMAGE_TOO_BIG => {
                    let lim = err
                        .raw()
                        .and_then(|j| j.get("limits"))
                        .and_then(|l| l.get("maxFileSize"))
                        .map(|v| v.to_string())
                        .unwrap_or_else(|| "unknown".to_string());
                    println!("Image file is too big, current limit is set to {lim}");
                }
                errors::LIMIT_MESSAGE => {
                    let lim = err
                        .raw()
                        .and_then(|j| j.get("limits"))
                        .and_then(|l| l.get("maxMessageLen"))
                        .map(|v| v.to_string())
                        .unwrap_or_else(|| "unknown".to_string());
                    println!("Message is too long, current limit is set to {lim}");
                }
                errors::LIMIT_PASSWORD => {
                    let lim = err
                        .raw()
                        .and_then(|j| j.get("limits"))
                        .and_then(|l| l.get("maxPasswordLen"))
                        .map(|v| v.to_string())
                        .unwrap_or_else(|| "unknown".to_string());
                    println!("Hasło jest za długie, bieżący limit to {lim}");
                }
                errors::INVALID_PASSWORD => {
                    println!("Nieprawidłowe hasło");
                }
                _ => {
                    println!("Wystąpił błąd: {}", err.error_message());
                }
            }
        }
    }
}
/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie zobaczymy, jak ukryć zaszyfrowaną wiadomość w
 * pliku graficznego przy użyciu naszego kodeka.
 *
 * Wersja      : v1.00
 * Język     : C#
 * Autor       : Bartosz Wójcik
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using System.Text.Json;
using PELock;

// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// utwórz instancję klasy Steganography Online Codec (placeholder klucza aktywacyjnego)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// zakoduj ukrytą wiadomość w źródłowym pliku graficznym
// w pełnej wersji limit rozmiaru obrazu to 10 MB (demo: maks. 50 kB)
// obsługiwane formaty obrazów to PNG, JPG, GIF, BMP, WBMP, GD2, AVIF, WEBP (napisz, jeśli potrzebujesz więcej)
string inputFilePath = "input_file.webp";

// w pełnej wersji rozmiar wiadomości jest nieograniczony (demo: maks. 16 znaków)
const string SecretMessage = "Secret message";

// w pełnej wersji hasło ma maks. 128 znaków (demo: maks. 8 znaków)
const string Password = "Pa$$word";

// gdzie zapisać zakodowany obraz z tajną wiadomością
string outputFilePath = "output_file_with_hidden_secret_message.png";

try
{
	// zakoduj ukrytą wiadomość (zaszyfrowaną hasłem) w pliku graficznym
	EncodeResult result =
		await codec.EncodeAsync(inputFilePath, SecretMessage, Password, outputFilePath).ConfigureAwait(false);

	string versionType = result.License?.ActivationStatus == true ? "full" : "demo";
	Console.WriteLine($"Działasz w wersji {versionType}");

	Console.WriteLine($"Tajna wiadomość zakodowana i zapisana do {outputFilePath}");

	if (result.License?.UsagesCount.HasValue ?? false)
		Console.WriteLine($"Pozostała liczba kredytów użycia - {result.License!.UsagesCount}");
}
catch (SteganographyApiException err)
{
	int errorCode = err.Error;

	switch (errorCode)
	{
	case Errors.InvalidInput:
		Console.WriteLine($"Nieprawidłowy plik wejściowy {inputFilePath} albo plik nie istnieje");
		break;
	case Errors.MessageTooLong:
		Console.WriteLine("Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku");
		break;
	case Errors.ImageTooBig:
		Console.WriteLine($"Image file is too big, current limit is set to {ReadLimitLong(err.Raw, "maxFileSize")}");
		break;
	case Errors.LimitMessage:
		Console.WriteLine($"Message is too long, current limit is set to {ReadLimitLong(err.Raw, "maxMessageLen")}");
		break;
	case Errors.LimitPassword:
		Console.WriteLine($"Hasło jest za długie, bieżący limit to {ReadLimitLong(err.Raw, "maxPasswordLen")}");
		break;
	case Errors.InvalidPassword:
		Console.WriteLine("Nieprawidłowe hasło");
		break;
	default:
		Console.WriteLine($"Wystąpił błąd: {(!string.IsNullOrEmpty(err.Message) ? err.Message : $"Kod błędu {errorCode}")}");
		break;
	}
}

static string ReadLimitLong(JsonElement? payload, string key)
{
	if (payload.HasValue &&
		payload.Value.TryGetProperty("limits", out JsonElement limits) &&
		limits.TryGetProperty(key, out JsonElement probe) &&
		probe.ValueKind == JsonValueKind.Number &&
		probe.TryGetInt64(out long value))
	{
		return value.ToString();
	}

	return "unknown";
}

/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ukryj tajną wiadomość z rozszerzoną obsługą błędów.
 *
 * Wersja        : v1.0.2
 * Język       : Go
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	steganographyonlinecodec "github.com/PELock/Steganography-Online-Codec-Go"
)

func main() {
	client := steganographyonlinecodec.New("YOUR-WEB-API-KEY")
	inputFile := "input_file.webp"
	result, err := client.Encode(context.Background(), inputFile, "Secret message", "Pa$$word", "output_file_with_hidden_secret_message.png")
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}

	switch result.Error {
	case steganographyonlinecodec.ErrorSuccess:
		fmt.Println("Tajna wiadomość zakodowana i zapisana do the output PNG file.")
	case steganographyonlinecodec.ErrorInvalidInput:
		fmt.Printf("Nieprawidłowy plik wejściowy %s albo plik nie istnieje\n", inputFile)
	case steganographyonlinecodec.ErrorMessageTooLong:
		fmt.Println("Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku")
	case steganographyonlinecodec.ErrorImageTooBig:
		fmt.Println("Image file is too big")
	case steganographyonlinecodec.ErrorLimitMessage:
		fmt.Println("Message is too long")
	case steganographyonlinecodec.ErrorLimitPassword:
		fmt.Println("Hasło jest za długie")
	case steganographyonlinecodec.ErrorInvalidPassword:
		fmt.Println("Nieprawidłowe hasło")
	default:
		fmt.Printf("Wystąpił nieznany błąd, kod błędu: %d\n", result.Error)
	}
}
/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Ukryj tajną wiadomość z rozszerzoną obsługą błędów.
 *
 * Wersja        : v1.0.2
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.fasterxml.jackson.databind.JsonNode;
import com.pelock.steganography.Errors;
import com.pelock.steganography.SteganographyOnlineCodec;

public class SteganographyExtendedExample {

  public static void main(String[] args) throws Exception {
    SteganographyOnlineCodec client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");
    String inputFilePath = "input_file.webp";
    String outputFilePath = "output_file_with_hidden_secret_message.png";
    JsonNode result = client.encode(inputFilePath, "Secret message", "Pa$$word", outputFilePath);

    if (result == null || !result.has("error")) {
      System.out.println("Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.");
      return;
    }

    boolean full = result.path("license").path("activationStatus").asBoolean(false);
    System.out.println("Działasz w wersji " + (full ? "pełnej" : "demonstracyjnej") + "");

    switch (result.get("error").asInt()) {
      case Errors.SUCCESS:
        System.out.println("Tajna wiadomość zakodowana i zapisana do " + outputFilePath);
        System.out.println(
            "Pozostała liczba kredytów użycia - " + result.path("license").path("usagesCount").asText());
        break;
      case Errors.INVALID_INPUT:
        System.out.println("Nieprawidłowy plik wejściowy " + inputFilePath + " albo plik nie istnieje");
        break;
      case Errors.MESSAGE_TOO_LONG:
        System.out.println("Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku");
        break;
      case Errors.IMAGE_TOO_BIG:
        System.out.println(
            "Image file is too big, current limit is set to "
                + result.path("limits").path("maxFileSize").asText());
        break;
      case Errors.LIMIT_MESSAGE:
        System.out.println(
            "Message is too long, current limit is set to "
                + result.path("limits").path("maxMessageLen").asText());
        break;
      case Errors.LIMIT_PASSWORD:
        System.out.println(
            "Hasło jest za długie, bieżący limit to "
                + result.path("limits").path("maxPasswordLen").asText());
        break;
      case Errors.INVALID_PASSWORD:
        System.out.println("Nieprawidłowe hasło");
        break;
      default:
        System.out.println("Wystąpił nieznany błąd, kod błędu: " + result.get("error").asInt());
        break;
    }
  }
}
<?php

declare(strict_types=1);

use PELock\SteganographyOnlineCodec\Errors;
use PELock\SteganographyOnlineCodec\SteganographyOnlineCodec;

require __DIR__ . "/vendor/autoload.php";

$client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

$inputFilePath = "input_file.webp";
$secretMessage = "Secret message";
$password = "Pa$$word";
$outputFilePath = "output_file_with_hidden_secret_message.png";

$result = $client->encode($inputFilePath, $secretMessage, $password, $outputFilePath);

if ($result && array_key_exists("error", $result)) {
    $full = ($result["license"]["activationStatus"] ?? false) === true;
    echo "Działasz w wersji " . ($full ? "pełnej" : "demonstracyjnej") . "\n";

    if ($result["error"] === Errors::SUCCESS) {
        echo "Tajna wiadomość zakodowana i zapisana do {$outputFilePath}\n";
        echo "Pozostała liczba kredytów użycia - {$result["license"]["usagesCount"]}\n";
    } elseif ($result["error"] === Errors::INVALID_INPUT) {
        echo "Nieprawidłowy plik wejściowy {$inputFilePath} albo plik nie istnieje\n";
    } elseif ($result["error"] === Errors::MESSAGE_TOO_LONG) {
        echo "Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku\n";
    } elseif ($result["error"] === Errors::IMAGE_TOO_BIG) {
        echo "Image file is too big, current limit is set to {$result["limits"]["maxFileSize"]}\n";
    } elseif ($result["error"] === Errors::LIMIT_MESSAGE) {
        echo "Message is too long, current limit is set to {$result["limits"]["maxMessageLen"]}\n";
    } elseif ($result["error"] === Errors::LIMIT_PASSWORD) {
        echo "Hasło jest za długie, bieżący limit to {$result["limits"]["maxPasswordLen"]}\n";
    } elseif ($result["error"] === Errors::INVALID_PASSWORD) {
        echo "Nieprawidłowe hasło\n";
    } else {
        echo "Wystąpił nieznany błąd, kod błędu: {$result["error"]}\n";
    }
} else {
    echo "Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.\n";
}
################################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# Ukryj tajną wiadomość z rozszerzoną obsługą błędów.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module SteganographyOnlineCodec

$client = New-SteganographyOnlineCodec -ApiKey 'YOUR-WEB-API-KEY'
$inputFilePath = 'input_file.webp'
$outputFilePath = 'output_file_with_hidden_secret_message.png'
$result = $client.Encode($inputFilePath, 'Secret message', 'Pa$$word', $outputFilePath)

if ($result -and $result.ContainsKey('error')) {
    $full = $false
    if ($result.ContainsKey('license') -and $result.license.activationStatus) {
        $full = $true
    }
    Write-Host ("Działasz w wersji {0}" -f $(if ($full) { 'full' } else { 'demo' }))

    switch ($result.error) {
        ([SteganographyErrors]::SUCCESS) {
            Write-Host ("Tajna wiadomość zakodowana i zapisana do {0}" -f $outputFilePath)
            if ($result.ContainsKey('license')) {
                Write-Host ("Pozostała liczba kredytów użycia - {0}" -f $result.license.usagesCount)
            }
        }
        ([SteganographyErrors]::INVALID_INPUT) { Write-Host ("Nieprawidłowy plik wejściowy {0} albo plik nie istnieje" -f $inputFilePath) }
        ([SteganographyErrors]::MESSAGE_TOO_LONG) { Write-Host 'Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku' }
        ([SteganographyErrors]::IMAGE_TOO_BIG) { Write-Host 'Image file is too big' }
        ([SteganographyErrors]::LIMIT_MESSAGE) { Write-Host 'Message is too long' }
        ([SteganographyErrors]::LIMIT_PASSWORD) { Write-Host 'Hasło jest za długie' }
        ([SteganographyErrors]::INVALID_PASSWORD) { Write-Host 'Nieprawidłowe hasło' }
        default { Write-Host ("Wystąpił nieznany błąd, kod błędu: {0}" -f $result.error) }
    }
}
else {
    Write-Host 'Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego.'
}
# frozen_string_literal: true

###############################################################################
#
# Steganography Online Codec — ukrycie z rozszerzoną obsługą błędów
#
# Wersja        : v1.0.2
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "steganography-online-codec"

client = SteganographyOnlineCodec.new("YOUR-WEB-API-KEY")
input_file_path = "input_file.webp"
output_file_path = "output_file_with_hidden_secret_message.png"
result = client.encode(input_file_path, "Secret message", "Pa$$word", output_file_path)

if result && result.key?("error")
  full = result.dig("license", "activationStatus") == true
  puts "Działasz w wersji #{full ? "pełnej" : "demonstracyjnej"}"

  case result["error"]
  when SteganographyOnlineCodec::Errors::SUCCESS
    puts "Tajna wiadomość zakodowana i zapisana do #{output_file_path}"
    puts "Pozostała liczba kredytów użycia - #{result.dig("license", "usagesCount")}"
  when SteganographyOnlineCodec::Errors::INVALID_INPUT
    puts "Nieprawidłowy plik wejściowy #{input_file_path} albo plik nie istnieje"
  when SteganographyOnlineCodec::Errors::MESSAGE_TOO_LONG
    puts "Wiadomość jest za długa dla podanego pliku graficznego, użyj większego pliku"
  when SteganographyOnlineCodec::Errors::IMAGE_TOO_BIG
    puts "Image file is too big, current limit is set to #{result.dig("limits", "maxFileSize")}"
  when SteganographyOnlineCodec::Errors::LIMIT_MESSAGE
    puts "Message is too long, current limit is set to #{result.dig("limits", "maxMessageLen")}"
  when SteganographyOnlineCodec::Errors::LIMIT_PASSWORD
    puts "Hasło jest za długie, bieżący limit to #{result.dig("limits", "maxPasswordLen")}"
  when SteganographyOnlineCodec::Errors::INVALID_PASSWORD
    puts "Nieprawidłowe hasło"
  else
    puts "Wystąpił nieznany błąd, kod błędu: #{result["error"]}"
  end
else
  warn "Podczas kodowania wiadomości wydarzyło się coś nieoczekiwanego."
end
#!/usr/bin/env bash

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu REST.
#
# W tym przykładzie ukryjemy wiadomość i odczytamy błąd JSON.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"
#
# to samo wywołanie kodowania. HTTP 422 to treść JSON zamiast encoded.png.
# X-PELock-Result jest obecny tylko wtedy, gdy zwracany jest PNG.
#
#
# ukryj wiadomość w obrazie
#
# response body    - encoded PNG, saved as encoded.png
# X-PELock-Result  - status JSON obok obrazu
#
# nieudane kodowanie to HTTP 422 i treść JSON zamiast obrazu
curl -sS -D - -o encoded.png \
  -H "Authorization: Bearer ${API_KEY}" \
  -F "file=@input_file.jpg" \
  -F "message=Secret message" \
  -F 'password=Pa$$word' \
  "https://www.pelock.com/api/steganography-online-codec/v1/encode"

Sprawdzenie danych licencyjnych

#!/usr/bin/env python

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
#
# Wersja      : v1.00
# Język     : Python
# Autor       : Bartosz Wójcik
# Projekt      : https://www.pelock.com/products/steganography-online-codec
# Strona       : https://www.pelock.com
#
###############################################################################

#
# include Steganography Online Codec module
#
from steganography_online_codec import *

#
# jeśli nie chcesz używać modułu Pythona, możesz zaimportować go bezpośrednio z pliku
#
#from pelock.steganography_online_codec import *

#
# utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
#
mySteganographyOnlineCodec = SteganographyOnlineCodec("YOUR-WEB-API-KEY")

#
# logowanie do usługi
#
result = mySteganographyOnlineCodec.login()

#
# słownik result[] zawiera informacje o licencji i bieżące limity
#
if result:

    print(f'Działasz w wersji {"pełnej" if result["license"]["activationStatus"] is True else "demonstracyjnej"}')

    # informacje o bieżącej licencji
    if result["license"]["activationStatus"] is True:
        print(f'Zarejestrowano dla - {result["license"]["userName"]}')
        print(f'Typ licencji - {"personal" if result["license"]["type"] == 0 else "company"}')
        print(f'Łączna liczba zakupionych kredytów użycia - {result["license"]["usagesTotal"]}')
        print(f'Pozostała liczba kredytów użycia - {result["license"]["usagesCount"]}')

    # bieżące limity (inne dla wersji DEMO i FULL)
    print(f'Maks. długość hasła - {result["limits"]["maxPasswordLen"]}')
    print(f'Max. message length - {"unlimited" if result["limits"]["maxMessageLen"] == -1 else result["limits"]["maxMessageLen"]}')
    print(f'Max. input image file size - {mySteganographyOnlineCodec.convert_size(result["limits"]["maxFileSize"])}')
else:
    print("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.")
"use strict";

/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
 *
 * Wersja      : v1.00
 * Język     : JavaScript
 * Autor       : Bartosz Wójcik
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @link https://www.pelock.com/products/steganography-online-codec
 * @copyright Copyright (c) 2020-2025 PELock LLC
 * @license Apache-2.0
 *
 /*****************************************************************************/

// include Steganography Online Codec module
import { SteganographyOnlineCodec, Errors } from 'steganography-online-codec';
// or if tested locally use:
//import { SteganographyOnlineCodec, Errors } from '../src/SteganographyOnlineCodec.mjs';

// utwórz instancję klasy Steganography Online Codec (używamy naszego klucza aktywacyjnego)
const mySteganographyOnlineCodec = new SteganographyOnlineCodec('YOUR-WEB-API-KEY');

// logowanie do usługi
(async () => {
	try {
		const result = await mySteganographyOnlineCodec.login();

		// obiekt result zawiera informacje o licencji i bieżące limity
		const versionType = result.license && result.license.activationStatus ? 'full' : 'demo';
		console.log(`Działasz w wersji ${versionType}`);

		// informacje o bieżącej licencji
		if (result.license && result.license.activationStatus) {
			console.log(`Zarejestrowano dla - ${result.license.userName}`);
			const licenseType = result.license.type === 0 ? 'personal' : 'company';
			console.log(`Typ licencji - ${licenseType}`);
			console.log(`Łączna liczba zakupionych kredytów użycia - ${result.license.usagesTotal}`);
			console.log(`Pozostała liczba kredytów użycia - ${result.license.usagesCount}`);
		}

		// bieżące limity (inne dla wersji DEMO i FULL)
		if (result.limits) {
			console.log(`Maks. długość hasła - ${result.limits.maxPasswordLen}`);
			const msgLen = result.limits.maxMessageLen === -1 ? 'unlimited' : result.limits.maxMessageLen;
			console.log(`Max. message length - ${msgLen}`);
			console.log(`Max. input image file size - ${mySteganographyOnlineCodec.convert_size(result.limits.maxFileSize)}`);
		}
	} catch (err) {
		console.error(`Login failed: ${err.error_message || String(err)}`);
	}
})();
// Przykład: sprawdzenie stanu licencji i bieżących limitów API (`login`).

use steganography_online_codec::SteganographyOnlineCodec;

#[tokio::main]
async fn main() {
    let my_steganography_online_codec =
        SteganographyOnlineCodec::new(Some("YOUR-WEB-API-KEY".to_string()));

    match my_steganography_online_codec.login().await {
        Ok(result) => {
            let version_type = result
                .license
                .as_ref()
                .and_then(|l| l.activation_status)
                .unwrap_or(false);
            println!(
                "Działasz w wersji {}",
                if version_type { "full" } else { "demo" }
            );

            if let Some(ref lic) = result.license {
                if lic.activation_status.unwrap_or(false) {
                    if let Some(ref name) = lic.user_name {
                        println!("Zarejestrowano dla - {name}");
                    }
                    let license_type = if lic.license_type == Some(0) {
                        "personal"
                    } else {
                        "company"
                    };
                    println!("Typ licencji - {license_type}");
                    if let Some(t) = lic.usages_total {
                        println!("Łączna liczba zakupionych kredytów użycia - {t}");
                    }
                    if let Some(c) = lic.usages_count {
                        println!("Pozostała liczba kredytów użycia - {c}");
                    }
                }
            }

            if let Some(ref limits) = result.limits {
                if let Some(m) = limits.max_password_len {
                    println!("Maks. długość hasła - {m}");
                }
                if let Some(ml) = limits.max_message_len {
                    let msg_len = if ml == -1 {
                        "unlimited".to_string()
                    } else {
                        ml.to_string()
                    };
                    println!("Max. message length - {msg_len}");
                }
                if let Some(fs) = limits.max_file_size {
                    println!(
                        "Max. input image file size - {}",
                        SteganographyOnlineCodec::convert_size(fs)
                    );
                }
            }
        }
        Err(err) => {
            eprintln!("Login failed: {}", err.error_message());
        }
    }
}
/******************************************************************************
 *
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * W tym przykładzie sprawdzimy stan klucza aktywacyjnego.
 *
 * Wersja      : v1.00
 * Język     : C#
 * Autor       : Bartosz Wójcik
 * Projekt      : https://www.pelock.com/products/steganography-online-codec
 * Strona       : https://www.pelock.com
 *
 * @copyright Copyright (c) 2020-2026 PELock LLC
 * @license Apache-2.0
 *
 ******************************************************************************/

using PELock;

// NuGet PackageReference Include="SteganographyOnlineCodec"
// or locally: dotnet add reference ..\src\SteganographyOnlineCodec\SteganographyOnlineCodec.csproj

// utwórz instancję klasy Steganography Online Codec (placeholder klucza aktywacyjnego)
using var codec = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");

// logowanie do usługi
try
{
	LoginResult result =
		await codec.LoginAsync().ConfigureAwait(false);

	string versionType =
		result.License?.ActivationStatus == true ? "full" : "demo";

	Console.WriteLine($"Działasz w wersji {versionType}");

	if (result.License?.ActivationStatus == true)
	{
		Console.WriteLine($"Zarejestrowano dla - {result.License!.UserName}");
		string licenseType = result.License.Type == 0 ? "personal" : "company";
		Console.WriteLine($"Typ licencji - {licenseType}");
		Console.WriteLine($"Łączna liczba zakupionych kredytów użycia - {result.License.UsagesTotal}");
		Console.WriteLine($"Pozostała liczba kredytów użycia - {result.License.UsagesCount}");
	}

	if (result.Limits != null)
	{
		Console.WriteLine($"Maks. długość hasła - {result.Limits.MaxPasswordLen}");
		string msgLen = result.Limits.MaxMessageLen == -1 ? "unlimited" : result.Limits.MaxMessageLen.ToString();
		Console.WriteLine($"Max. message length - {msgLen}");
		Console.WriteLine($"Max. input image file size - {codec.ConvertSize(result.Limits.MaxFileSize)}");
	}
}
catch (SteganographyApiException err)
{
	Console.Error.WriteLine("Login failed: " + (!string.IsNullOrEmpty(err.Message) ? err.Message : $"Kod błędu {err.Error}"));
}

/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Sprawdź klucz aktywacyjny i stan trybu demo.
 *
 * Wersja        : v1.0.2
 * Język       : Go
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

package main

import (
	"context"
	"fmt"
	"os"

	steganographyonlinecodec "github.com/PELock/Steganography-Online-Codec-Go"
)

func main() {
	client := steganographyonlinecodec.New("YOUR-WEB-API-KEY")
	result, err := client.Login(context.Background())
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if result.Demo {
		fmt.Println("Działasz w wersji demonstracyjnej")
	} else {
		fmt.Println("Działasz w wersji pełnej")
	}
	fmt.Printf("error=%d demo=%v\n", result.Error, result.Demo)
}
/******************************************************************************
 * Steganography Online Codec — przykład użycia interfejsu Web API.
 *
 * Sprawdź klucz aktywacyjny i stan trybu demo.
 *
 * Wersja        : v1.0.2
 * Język       : Java
 * Autor         : Bartosz Wójcik
 * Strona       : https://www.pelock.com
 *
 *****************************************************************************/

import com.fasterxml.jackson.databind.JsonNode;
import com.pelock.steganography.SteganographyOnlineCodec;

public class SteganographyIsDemo {

  public static void main(String[] args) throws Exception {
    SteganographyOnlineCodec client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");
    JsonNode result = client.login();

    if (result != null && result.has("license")) {
      boolean full = result.path("license").path("activationStatus").asBoolean(false);
      System.out.println("Działasz w wersji " + (full ? "pełnej" : "demonstracyjnej") + "");
      if (full) {
        System.out.println("Zarejestrowano dla - " + result.path("license").path("userName").asText());
        System.out.println(
            "Pozostała liczba kredytów użycia - "
                + result.path("license").path("usagesCount").asText());
      }
      System.out.println("Maks. długość hasła - " + result.path("limits").path("maxPasswordLen").asText());
    } else {
      System.out.println("Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.");
    }
  }
}
<?php

declare(strict_types=1);

use PELock\SteganographyOnlineCodec\SteganographyOnlineCodec;

require __DIR__ . "/vendor/autoload.php";

$client = new SteganographyOnlineCodec("YOUR-WEB-API-KEY");
$result = $client->login();

if ($result) {
    $full = ($result["license"]["activationStatus"] ?? false) === true;
    echo "Działasz w wersji " . ($full ? "pełnej" : "demonstracyjnej") . "\n";
    if ($full) {
        echo "Zarejestrowano dla - {$result["license"]["userName"]}\n";
        echo "Pozostała liczba kredytów użycia - {$result["license"]["usagesCount"]}\n";
    }
    echo "Maks. długość hasła - {$result["limits"]["maxPasswordLen"]}\n";
} else {
    echo "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.\n";
}
################################################################################
#
# Steganography Online Codec — przykład użycia interfejsu Web API.
#
# Sprawdź klucz aktywacyjny i stan trybu demo.
#
# Wersja        : v1.0.0
# Język       : PowerShell
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
################################################################################

using module SteganographyOnlineCodec

$client = New-SteganographyOnlineCodec -ApiKey 'YOUR-WEB-API-KEY'
$result = $client.Login()

if ($result) {
    $full = $false
    if ($result.ContainsKey('license') -and $result.license.activationStatus) {
        $full = $true
    }
    Write-Host ("Działasz w wersji {0}" -f $(if ($full) { 'full' } else { 'demo' }))
    if ($full) {
        Write-Host ("Zarejestrowano dla - {0}" -f $result.license.userName)
        Write-Host ("Pozostała liczba kredytów użycia - {0}" -f $result.license.usagesCount)
    }
    if ($result.ContainsKey('limits')) {
        Write-Host ("Maks. długość hasła - {0}" -f $result.limits.maxPasswordLen)
    }
}
else {
    Write-Host 'Podczas logowania do usługi wydarzyło się coś nieoczekiwanego.'
}
# frozen_string_literal: true

###############################################################################
#
# Steganography Online Codec — login
#
# Wersja        : v1.0.2
# Język       : Ruby
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

require "steganography-online-codec"

client = SteganographyOnlineCodec.new("YOUR-WEB-API-KEY")
result = client.login

if result
  full = result.dig("license", "activationStatus") == true
  puts "Działasz w wersji #{full ? "pełnej" : "demonstracyjnej"}"
  if full
    puts "Zarejestrowano dla - #{result.dig("license", "userName")}"
    puts "Pozostała liczba kredytów użycia - #{result.dig("license", "usagesCount")}"
  end
  puts "Maks. długość hasła - #{result.dig("limits", "maxPasswordLen")}"
else
  warn "Podczas logowania do usługi wydarzyło się coś nieoczekiwanego."
end
#!/usr/bin/env bash

###############################################################################
#
# Steganography Online Codec — przykład użycia interfejsu REST.
#
# W tym przykładzie sprawdzimy informacje o licencji.
#
# Wersja        : v1.0.0
# Język       : curl
# Autor         : Bartosz Wójcik
# Strona       : https://www.pelock.com
#
###############################################################################

#
# klucz aktywacyjny (pusty lub nieprawidłowy klucz uruchamia tryb demo)
#
API_KEY="ABCD-ABCD-ABCD-ABCD"

#
# logowanie do usługi
#
# Treść JSON:
#
# license.activationStatus - true, gdy klucz jest aktywny
# license.userName         - właściciel, gdy klucz jest aktywny
# license.type             - typ licencji
# license.usagesTotal      - łączna liczba użyć
# license.usagesCount      - dotychczasowe użycia
# limits.maxPasswordLen    - password length limit
# limits.maxMessageLen     - limit długości wiadomości
# limits.maxFileSize       - limit rozmiaru obrazu

curl -sS \
  -H "Authorization: Bearer ${API_KEY}" \
  "https://www.pelock.com/api/steganography-online-codec/v1/license"

Zwracane wartości

result["error"] [out]
Kod błędu. Jeden z poniższych:
Nazwa Wartość Opis
WEBAPI_CONNECTION -1 Nie można połączyć się z interfejsem Web API (błąd sieci, zwracany jedynie przez bibliotekę SDK).
SUCCESS 0 Wszystko poszło ok.
UNKNOWN 1 Nieznany błąd.
MESSAGE_TOO_LONG 2 Wiadomość jest zbyt długa dla wybranego pliku obrazka (użyj większy plik obrazka).
IMAGE_TOO_BIG 3 Plik obrazka zbyt duży (limit 10 MB dla pełnej wersji, 50 kB dla wersji DEMO).
INVALID_INPUT 4 Plik obrazka jest nieprawidłowy.
INVALID_IMAGE_FORMAT 5 Format pliku obrazka nie jest obsługiwany.
IMAGE_MALFORMED 6 Plik obrazka jest uszkodzony lub nie można go odczytać albo zapisać do niego zakodowanej wiadomości.
INVALID_PASSWORD 7 Podane hasło jest nieprawidłowe (maksymalny rozmiar hasła to 128 znaków dla pełnej wersji i 8 znaków dla wersji DEMO).
LIMIT_MESSAGE 9 Wiadomość jest zbyt długa (nieograniczony rozmiar dla pełnej wersji, 16 znaków dla wersji DEMO).
LIMIT_PASSWORD 10 Podane hasło ma nieprawidłowy rozmiar (rozmiar to maksymalnie 128 znaków dla pełnej wersji, 8 dla wersji DEMO).
OUTPUT_FILE 99 Błąd podczas zapisywania wyjściowego pliku (zwracany jedynie przez bibliotekę SDK).
INVALID_LICENSE 100 Klucz licencji jest nieprawidłowy lub wygasł (brak kredytów użycia).
result["message"] [out, optional]
Zdekodowana sekretna wiadomość.
result["limits"]["maxFileSize"] [out, optional]
Maksymalny dozwolony rozmiar pliku.
result["limits"]["maxMessageLen"] [out, optional]
Maksymalny dozwolony rozmiar sekretnej wiadomości (domyślnie -1 dla nieograniczonego rozmiaru, który pozwoli wpasować się w rozmiar pliku wejściowego).
result["limits"]["maxPasswordLen"] [out, optional]
Maksymalny dozwolony rozmiar hasła.
result["license"]["activationStatus"] [out, optional]
Status aktywacji - true dla pełnej wersji false dla wersji demo.
result["license"]["userName"] [out, optional]
Nazwa zarejestrowanego użytkownika.
result["license"]["type"] [out, optional]
Rodzaj licencji - 0 for Licencji Osobistej, 1 dla Licencji Firmowej.
result["license"]["usagesTotal"] [out, optional]
Całkowita liczba zakupionych kredytów użycia.
result["license"]["usagesCount"] [out]
Pozostała liczba kredytów użycia (zawsze zwracana przy kodowaniu/dekodowaniu, dla wersji demo jest zawsze ustawiona na 1).

Wymagania

Moduł dla Python steganography-online-codec
JavaScript NPM Module steganography-online-codec
Crate Rust steganography-online-codec
Pakiet NuGet (C# / .NET) SteganographyOnlineCodec

Masz pytania?

Jeśli masz jakieś pytania dotyczące pakietów SDK dla Steganografia Kodek Online, masz jakieś uwagi, coś jest niejasne, napisz do mnie, chętnie odpowiem na każde Twoje pytanie.