Github: https://github.com/HNP-Christopher-Rohde/hnp-example-blockchain-with-miner

Blockchain

Die Blockchain in diesem System ist eine auf Blöcken basierende Kette, die kryptografisch gesichert ist. Jeder Block enthält folgende Informationen:

Index: Die Position des Blocks in der Kette.
Zeitstempel: Der Zeitpunkt, zu dem der Block erstellt wurde (in Unix-Zeit).
Daten: Die im Block gespeicherten Informationen (in binärer Form).
Vorheriger Hash: Der Hash des vorhergehenden Blocks, der die Verbindung zu diesem sicherstellt.
Hash: Der eigene Hash des Blocks, der durch den Hashing-Algorithmus SHA-256 berechnet wird.
Nonce: Eine Zahl, die während des Minings variiert wird, um den Hash zu finden, der den Anforderungen der Schwierigkeit entspricht.

Die Blockchain wird mit einem Genesis-Block initialisiert. Jeder neue Block wird durch einen Mining-Prozess erstellt, der den Hash so anpasst, dass er den Schwierigkeitsanforderungen (Difficulty) entspricht, d. h. der Hash muss mit einer bestimmten Anzahl von Nullen beginnen. Die Schwierigkeit passt sich dynamisch an, basierend auf der Zeit, die für die Erstellung der letzten Blöcke benötigt wurde.

Validität der Blockchain:

Jeder Block in der Kette wird überprüft, um sicherzustellen, dass der Hash korrekt ist und der Hash des vorherigen Blocks mit dem gespeicherten previous_hash übereinstimmt.
Es wird außerdem geprüft, ob der Block die Schwierigkeit (Difficulty) erfüllt, bevor er zur Kette hinzugefügt wird.

Die Blockchain speichert die Blöcke auf der Festplatte (z. B. in der Datei blockchain.json) und bietet APIs für den Empfang und das Senden neuer Blöcke zwischen Peers.

Blockchain:

use serde::{Serialize, Deserialize};
use std::collections::VecDeque;
use std::fs;
use sha2::Digest;
use hex;
use std::time::{SystemTime, UNIX_EPOCH};
use reqwest;
use warp::Filter;
use log::{info, error};
use std::env;
use std::sync::{Arc, Mutex};

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Block {
    pub index: u64,
    pub timestamp: u64,
    pub data: Vec<u8>,
    pub previous_hash: String,
    pub hash: String,
    pub nonce: u64,
}

impl Block {
    pub fn new(index: u64, data: Vec<u8>, previous_hash: String) -> Self {
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
        let mut block = Block {
            index,
            timestamp,
            data,
            previous_hash,
            hash: String::new(),
            nonce: 0,
        };
        block.hash = block.calculate_hash();
        info!("Created new block: {:?}", block);
        block
    }

    pub fn calculate_hash(&self) -> String {
        let mut hasher = sha2::Sha256::new();
        hasher.update(format!("{}{}{}{}{}", self.index, self.timestamp, hex::encode(&self.data), self.previous_hash, self.nonce));
        let result = hasher.finalize();
        hex::encode(result)
    }
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Blockchain {
    pub chain: VecDeque<Block>,
    pub difficulty: u32,
    pub adjustment_interval: u64,
    pub target_block_time: u64,
    pub last_difficulty_update: u64,
}

impl Blockchain {
    pub fn new(difficulty: u32, adjustment_interval: u64, target_block_time: u64) -> Self {
        let mut chain = VecDeque::new();
        chain.push_back(create_genesis_block());
        info!("Blockchain initialized with genesis block");
        Blockchain {
            chain,
            difficulty,
            adjustment_interval,
            target_block_time,
            last_difficulty_update: SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs(),
        }
    }

    pub fn add_block(&mut self, data: Vec<u8>) {
        let previous_block = self.chain.back().unwrap();
        let new_block = mine_block(previous_block, data, self.difficulty);
        info!("Adding new block: {:?}", new_block);
        self.chain.push_back(new_block);
    
        // Update difficulty if needed
        if (self.chain.len() as u64) % self.adjustment_interval == 0 {
            self.update_difficulty_based_on_time();
        }
    
        if let Err(e) = self.save_to_file("blockchain.json") {
            error!("Failed to save blockchain after adding block: {}", e);
        }
    }
    
    pub fn is_valid(&self) -> bool {
        for i in 1..self.chain.len() {
            let current = &self.chain[i];
            let previous = &self.chain[i - 1];

            if current.hash != current.calculate_hash() {
                error!("Block {} has invalid hash", current.index);
                return false;
            }

            if current.previous_hash != previous.hash {
                error!("Block {} has invalid previous hash", current.index);
                return false;
            }

            if !meets_difficulty(&current.hash, self.difficulty) {
                error!("Block {} does not meet difficulty", current.index);
                return false;
            }
        }
        true
    }

    pub fn save_to_file(&self, filename: &str) -> std::io::Result<()> {
        let serialized = serde_json::to_string(self)
            .expect("Serialization failed");
        fs::write(filename, serialized).map_err(|e| {
            error!("Failed to write blockchain to file: {}", e);
            e
        })?;
        info!("Blockchain saved to file: {}", filename);
        Ok(())
    }
    
    pub fn load_from_file(filename: &str) -> std::io::Result<Self> {
        match fs::read_to_string(filename) {
            Ok(data) if !data.is_empty() => {
                match serde_json::from_str::<Blockchain>(&data) {
                    Ok(blockchain) => {
                        info!("Blockchain loaded from file: {}", filename);
                        Ok(blockchain)
                    }
                    Err(e) => {
                        info!("Failed to deserialize blockchain from file, creating a new one: {}", e);
                        let (difficulty, adjustment_interval, target_block_time) = load_config();
                        Ok(Blockchain::new(difficulty, adjustment_interval, target_block_time))
                    }
                }
            }
            _ => {
                info!("Blockchain file is empty or not found. Creating a new blockchain.");
                let (difficulty, adjustment_interval, target_block_time) = load_config();
                Ok(Blockchain::new(difficulty, adjustment_interval, target_block_time))
            }
        }
    }
    
    pub async fn broadcast_new_block(&self, block: &Block, peers: &[&str]) -> reqwest::Result<()> {
        for peer in peers {
            let url = format!("{}/new-block", peer);
            info!("Broadcasting new block to peer: {}", url);
            let result = reqwest::Client::new()
                .post(&url)
                .json(&block)
                .send()
                .await;

            match result {
                Ok(_) => info!("Successfully sent block to {}", url),
                Err(e) => error!("Failed to send block to {}: {:?}", url, e),
            }
        }
        Ok(())
    }

    pub fn add_block_from_request(&mut self, block: Block) -> bool {
        let previous_block = self.chain.back().unwrap();

        info!("Received block: {:?}", block);
        info!("Last block in chain: {:?}", previous_block);

        // Additional validation for the timestamp
        if block.timestamp <= previous_block.timestamp {
            error!("Block timestamp is not valid");
            return false;
        }

        let is_valid = block.index == previous_block.index + 1
            && block.previous_hash == previous_block.hash
            && block.hash == block.calculate_hash()
            && meets_difficulty(&block.hash, self.difficulty);
        
        if is_valid {
            info!("Valid block received and added to chain");
            self.chain.push_back(block);
            if let Err(e) = self.save_to_file("blockchain.json") {
                error!("Failed to save blockchain after adding block: {}", e);
            }
        } else {
            error!("Invalid block received: \n\
                    Index: {} \n\
                    Previous Hash: {} \n\
                    Expected Previous Hash: {} \n\
                    Hash: {} \n\
                    Calculated Hash: {} \n\
                    Difficulty Met: {}",
                block.index,
                block.previous_hash,
                previous_block.hash,
                block.hash,
                block.calculate_hash(),
                meets_difficulty(&block.hash, self.difficulty));
        }
        
        is_valid
    }
    
    pub fn update_difficulty_based_on_time(&mut self) {
        let length = self.chain.len() as u64;
        info!("Chain length: {}", length);
        
        if length >= self.adjustment_interval {
            let interval_start_block = &self.chain[self.chain.len() - self.adjustment_interval as usize];
            let interval_end_block = self.chain.back().unwrap();
    
            let time_taken = interval_end_block.timestamp - interval_start_block.timestamp;
            let expected_time = self.adjustment_interval * self.target_block_time;
    
            info!("Time taken for the last {} blocks: {} seconds", self.adjustment_interval, time_taken);
            info!("Expected time for the last {} blocks: {} seconds", self.adjustment_interval, expected_time);
    
            if time_taken < expected_time / 2 {
                self.difficulty += 1;
                info!("Difficulty increased to {}", self.difficulty);
            } else if time_taken > expected_time * 2 {
                if self.difficulty > 1 {
                    self.difficulty -= 1;
                    info!("Difficulty decreased to {}", self.difficulty);
                }
            } else {
                info!("Difficulty remains at {}", self.difficulty);
            }
    
            // Update the last difficulty update timestamp
            self.last_difficulty_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
        } else {
            info!("Not enough blocks to adjust difficulty.");
        }
    }
    
    
    pub fn update_difficulty(&mut self, new_difficulty: u32) {
        self.difficulty = new_difficulty;
        info!("Difficulty updated to {}", new_difficulty);
        if let Err(e) = self.save_to_file("blockchain.json") {
            error!("Failed to save blockchain after updating difficulty: {}", e);
        }
    }
}

pub fn create_genesis_block() -> Block {
    Block::new(0, "Genesis Block".as_bytes().to_vec(), "0".to_string())
}

fn meets_difficulty(hash: &str, difficulty: u32) -> bool {
    let target = vec![0u8; difficulty as usize];
    let hash_bytes = hex::decode(hash).expect("Hex decode failed");
    hash_bytes.len() >= target.len() && hash_bytes.starts_with(&target)
}

fn mine_block(previous_block: &Block, data: Vec<u8>, difficulty: u32) -> Block {
    let mut new_block = Block::new(previous_block.index + 1, data.clone(), previous_block.hash.clone());

    let mut attempt = 0;

    while !meets_difficulty(&new_block.hash, difficulty) {
        new_block.nonce += 1;
        new_block.hash = new_block.calculate_hash();

        attempt += 1;
        if attempt % 100 == 0 {
            println!("Attempt {}: Trying hash: {}", attempt, new_block.hash);
        }
    }

    new_block
}


fn load_config() -> (u32, u64, u64) {
    use serde::Deserialize;
    #[derive(Deserialize)]
    struct Config {
        initial_difficulty: u32,
        adjustment_interval: u64,
        target_block_time: u64,
    }

    let data = fs::read_to_string("config.json").expect("Unable to read config file");
    let config: Config = serde_json::from_str(&data).expect("Unable to parse config file");
    (config.initial_difficulty, config.adjustment_interval, config.target_block_time)
}

#[tokio::main]
async fn main() {
    env::set_var("RUST_LOG", "info");
    env_logger::init();

    let (initial_difficulty, adjustment_interval, target_block_time) = load_config();
    let blockchain = Arc::new(Mutex::new(
        Blockchain::load_from_file("blockchain.json").unwrap_or_else(|_| Blockchain::new(initial_difficulty, adjustment_interval, target_block_time))
    ));

    let blockchain_filter = warp::any().map(move || blockchain.clone());

    let new_block = warp::post()
        .and(warp::path("new-block"))
        .and(warp::body::json())
        .and(blockchain_filter.clone())
        .map(|block: Block, blockchain: Arc<Mutex<Blockchain>>| {
            let mut blockchain = blockchain.lock().unwrap();
            let response = if blockchain.add_block_from_request(block) {
                "Block added successfully"
            } else {
                "Invalid block"
            };
            response
        });

    let difficulty = warp::get()
        .and(warp::path("difficulty"))
        .map(move || format!("Difficulty: {}", initial_difficulty));

    let set_difficulty = warp::post()
        .and(warp::path("set-difficulty"))
        .and(warp::body::json())
        .and(blockchain_filter.clone())
        .map(|_new_difficulty: u32, _blockchain: Arc<Mutex<Blockchain>>| {
            // Ignoring difficulty change here, as it's handled externally
            format!("Difficulty updated to {}", _new_difficulty)
        });

    let last_block = warp::get()
        .and(warp::path("last-block"))
        .and(blockchain_filter.clone())
        .map(|blockchain: Arc<Mutex<Blockchain>>| {
            let blockchain = blockchain.lock().unwrap();
            let last_block = blockchain.chain.back().cloned().unwrap_or_else(|| create_genesis_block());
            warp::reply::json(&last_block)
        });

    let routes = new_block.or(difficulty).or(set_difficulty).or(last_block);

    info!("Starting server at http://127.0.0.1:8000");
    warp::serve(routes).run(([127, 0, 0, 1], 8000)).await;
}

Miner

Der Miner ist für die Erstellung neuer Blöcke in der Blockchain verantwortlich. Er arbeitet nach einem Proof-of-Work-Mechanismus, bei dem der Miner eine nonce-Nummer anpasst, bis ein gültiger Hash gefunden wird, der den Schwierigkeitsanforderungen entspricht.

Ablauf des Mining-Prozesses:

Der Miner fragt den letzten Block der Blockchain von einem Server ab.
Der Miner fragt die aktuelle Schwierigkeit vom Server ab.
Ein neuer Block wird erstellt, indem die Daten des vorherigen Blocks verwendet werden, sowie neue Transaktionsdaten.
Der Miner berechnet den Hash des neuen Blocks durch Anpassung der nonce, bis der Hash die Schwierigkeit erfüllt (d. h., der Hash beginnt mit einer bestimmten Anzahl von Nullen).
Sobald ein gültiger Block gefunden wurde, wird er an den Server gesendet, der ihn zur Blockchain hinzufügt.

Der Mining-Prozess läuft in einem Loop, sodass kontinuierlich nach neuen Blöcken gesucht wird, die der Blockchain hinzugefügt werden können.

use serde::{Serialize, Deserialize};
use sha2::{Sha256, Digest};
use std::time::{SystemTime, UNIX_EPOCH};
use reqwest;
use hex;
use anyhow::{Result, Context};
use tokio::task;

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Block {
    pub index: u64,
    pub timestamp: u64,
    pub data: Vec<u8>,
    pub previous_hash: String,
    pub hash: String,
    pub nonce: u64,
}

impl Block {
    pub fn new(index: u64, data: Vec<u8>, previous_hash: String) -> Self {
        let timestamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
        let mut block = Block {
            index,
            timestamp,
            data,
            previous_hash,
            hash: String::new(),
            nonce: 0,
        };
        block.hash = block.calculate_hash();
        block
    }

    pub fn calculate_hash(&self) -> String {
        let mut hasher = Sha256::new();
        hasher.update(format!("{}{}{}{}{}", self.index, self.timestamp, hex::encode(&self.data), self.previous_hash, self.nonce));
        let result = hasher.finalize();
        hex::encode(result)
    }
}

fn meets_difficulty(hash: &str, difficulty: u32) -> bool {
    let target = vec![0u8; difficulty as usize];
    let hash_bytes = hex::decode(hash).expect("Hex decode failed");
    hash_bytes.starts_with(&target)
}

async fn mine_block(previous_block: &Block, data: Vec<u8>, difficulty: u32) -> Block {
    let mut new_block = Block::new(previous_block.index + 1, data.clone(), previous_block.hash.clone());

    // Parallel mining using multiple threads
    let mining_task = task::spawn_blocking(move || {
        let mut attempt = 0;
        while !meets_difficulty(&new_block.hash, difficulty) {
            new_block.nonce += 1;
            new_block.hash = new_block.calculate_hash();

            attempt += 1;
            if attempt % 100 == 0 {
                println!("Attempt {}: Trying hash: {}", attempt, new_block.hash);
            }
        }

        new_block
    });

    mining_task.await.unwrap()
}

async fn get_last_block_from_server() -> Result<Block> {
    let client = reqwest::Client::new();
    let url = "http://localhost:8000/last-block";

    let res = client.get(url)
        .send()
        .await
        .context("Failed to send request to get last block")?;

    let last_block: Block = res.json().await
        .context("Failed to parse last block")?;
    Ok(last_block)
}

async fn send_block_to_server(block: &Block) -> Result<()> {
    let client = reqwest::Client::new();
    let url = "http://localhost:8000/new-block";

    println!("Sending block: {:?}", block);

    let res = client.post(url)
        .json(block)
        .send()
        .await
        .context("Failed to send request to post new block")?;

    let status = res.status();
    let body = res.text().await
        .context("Failed to read response text")?;

    if status.is_success() {
        println!("Block successfully sent to server.");
    } else {
        println!("Failed to send block to server: {} - {}", status, body);
    }

    Ok(())
}

async fn get_difficulty_from_server() -> Result<u32> {
    let client = reqwest::Client::new();
    let url = "http://localhost:8000/difficulty";

    let res = client.get(url)
        .send()
        .await
        .context("Failed to send request to get difficulty")?;

    let difficulty_str = res.text().await
        .context("Failed to read difficulty response")?;
    let difficulty = difficulty_str.trim_start_matches("Difficulty: ")
        .parse::<u32>()
        .context("Failed to parse difficulty")?;

    Ok(difficulty)
}

async fn display_difficulty() -> Result<()> {
    let difficulty = get_difficulty_from_server().await
        .context("Error retrieving difficulty from server")?;

    println!("Current Difficulty: {}", difficulty);

    Ok(())
}

#[tokio::main]
async fn main() -> Result<()> {
    loop {
        // Anzeige der aktuellen Schwierigkeit
        display_difficulty().await
            .context("Error displaying difficulty")?;

        // Hol die Schwierigkeit vom Server
        let difficulty = get_difficulty_from_server().await
            .context("Error retrieving difficulty from server")?;

        // Hol den letzten Block vom Server
        let previous_block = get_last_block_from_server().await
            .context("Error retrieving last block from server")?;

        let data = b"Block data".to_vec();
        let new_block = mine_block(&previous_block, data, difficulty).await;

        send_block_to_server(&new_block).await
            .context("Error sending block to server")?;

        // Warte eine gewisse Zeit, bevor der nächste Block erstellt wird
        tokio::time::sleep(tokio::time::Duration::from_secs(0)).await; // Wartezeit erhöht
    }
}

Der Beitrag Simple Blockchain Beispiel mit Miner erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Was der HNP Win Data Handler macht

Der HNP Win Data Handler ist ein WordPress-Plugin kombiniert mit einer C#-Anwendung, die zusammenarbeiten, um Daten sicher zu verwalten und auszutauschen. Das WordPress-Plugin definiert spezifische REST-API-Endpunkte, die es einer C#-Anwendung ermöglichen, Daten zu lesen (GET) und zu schreiben (POST). Diese Daten können für eine Vielzahl von Anwendungen nützlich sein, beispielsweise für das Abrufen und Aktualisieren von Konfigurationseinstellungen, Nutzerdaten oder anderen dynamischen Inhalten, die auf der WordPress-Seite gepflegt werden.

Download Exe & WordPress Plugin (sofort kostenlos nutzbar):
[sdm_download id=”8231″ fancy=”0″]
Shortcode in WordPress für Anzeige der Daten: [hnp_win_data_display]

Github:
https://github.com/HNP-Christopher-Rohde/Hnp-win-data-handler/tree/main

C# Source-Code für die Win EXE / Anwendung:
Die C#-Komponente handhabt die Benutzereingaben und interagiert direkt mit der REST-API. Sie bietet Funktionen zum Ändern der Domain-URL, zum Laden von Daten aus WordPress und zum Speichern von Änderungen an den Daten. Diese Flexibilität macht es möglich, die Datenverwaltung von jeder C#-basierten Benutzeroberfläche aus zu steuern.

// HNP Win Data Handler v.1.0 EXE
// Author: HNP C.R.
// Author URI: https://homepage-nach-preis.de/
// Licence: Creative Commons Non-Commercial 

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;
using Newtonsoft.Json;

class hnp_win_data_Main
{
    private static readonly HttpClient client = new HttpClient();
    private static string domainFilePath = "hnp_win_data_domain.txt";
    private static string? domainUrl = null;

    private const string SecretKey = "9418BB768671A389";

    static async Task Main(string[] args)
    {
        client.DefaultRequestHeaders.Add("X-Secret-Key", SecretKey);

        await LoadDomain();
        while (true)
        {
            Console.WriteLine("\nMenu:");
            Console.WriteLine("1. Change Domain");
            Console.WriteLine("2. Load Data from WordPress");
            Console.WriteLine("3. Change and Save Data");
            Console.Write("Select an option: ");

            string? option = Console.ReadLine();
            switch (option)
            {
                case "1":
                    ChangeDomain();
                    break;
                case "2":
                    await LoadDataFromWordPress();
                    break;
                case "3":
                    await ChangeAndSaveData();
                    break;
                default:
                    Console.WriteLine("Invalid option.");
                    break;
            }
        }
    }

    static async Task LoadDomain()
    {
        if (File.Exists(domainFilePath))
        {
            domainUrl = await File.ReadAllTextAsync(domainFilePath) ?? string.Empty;
            Console.WriteLine($"Loaded domain: {domainUrl}");
        }
        else
        {
            Console.Write("Enter domain URL: ");
            domainUrl = Console.ReadLine();
            if (!string.IsNullOrWhiteSpace(domainUrl))
            {
                await File.WriteAllTextAsync(domainFilePath, domainUrl);
            }
        }
    }

    static void ChangeDomain()
    {
        Console.Write("Enter new domain URL: ");
        string? newDomainUrl = Console.ReadLine();
        if (!string.IsNullOrWhiteSpace(newDomainUrl))
        {
            domainUrl = newDomainUrl;
            File.WriteAllText(domainFilePath, domainUrl);
            Console.WriteLine("Domain updated successfully.");
        }
        else
        {
            Console.WriteLine("Invalid domain URL provided.");
        }
    }

    static async Task LoadDataFromWordPress()
    {
        if (!string.IsNullOrWhiteSpace(domainUrl))
        {
            try
            {
                HttpResponseMessage response = await client.GetAsync(domainUrl + "/wp-json/hnp-win-data/v1/data");
                response.EnsureSuccessStatusCode();
                string responseBody = await response.Content.ReadAsStringAsync();
                string decodedData = JsonConvert.DeserializeObject<string>(responseBody) ?? "Default or empty data";
                Console.WriteLine("Data loaded: " + decodedData);
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine("\nException Caught!");
                Console.WriteLine("Message :{0} ", e.Message);
            }
        }
        else
        {
            Console.WriteLine("Domain URL is not set. Please set the domain URL first.");
        }
    }

    static async Task ChangeAndSaveData()
    {
        Console.Write("Enter new data value: ");
        string? newData = Console.ReadLine();
        if (!string.IsNullOrWhiteSpace(newData) && !string.IsNullOrWhiteSpace(domainUrl))
        {
            var content = new StringContent($"\"{newData}\"", System.Text.Encoding.UTF8, "application/json");
            try
            {
                HttpResponseMessage response = await client.PostAsync(domainUrl + "/wp-json/hnp-win-data/v1/data", content);
                response.EnsureSuccessStatusCode();
                Console.WriteLine("Data saved successfully.");
            }
            catch (HttpRequestException e)
            {
                Console.WriteLine("\nException Caught!");
                Console.WriteLine("Message :{0} ", e.Message);
            }
        }
        else
        {
            Console.WriteLine("Invalid data value or domain URL is not set.");
        }
    }
}

PHP Source Code für das WordPress Plugin:
Das Plugin registriert zwei REST-API-Endpunkte: einen für GET-Anfragen, um Daten abzurufen, und einen für POST-Anfragen, um Daten zu aktualisieren. Jede Anfrage wird über eine Funktion verarbeitet, die den geheimen Schlüssel überprüft, um sicherzustellen, dass nur berechtigte Anfragen bearbeitet werden.

<?php

 /*
  Plugin Name: HNP Win Data Handler
  Description: Handles data via custom REST API for an external C# application with security enhancements.
  Version: 1.0
  Author: HNP C.R.
  Author URI: https://homepage-nach-preis.de/
  License: GPLv3
  License URI: https://www.gnu.org/licenses/gpl-3.0.html
  Shortcode: hnp_win_data_display
*/

define('HNP_WIN_DATA_SECRET_KEY', '9418BB768671A389');  // Set your secret key here

// Register REST API routes
add_action('rest_api_init', function () {
    register_rest_route('hnp-win-data/v1', '/data', array(
        'methods' => 'GET',
        'callback' => 'hnp_win_data_get_data',
        'permission_callback' => 'hnp_win_data_check_secret_key'
    ));
    register_rest_route('hnp-win-data/v1', '/data', array(
        'methods' => 'POST',
        'callback' => 'hnp_win_data_set_data',
        'permission_callback' => 'hnp_win_data_check_secret_key'
    ));
});

// Function to handle GET request
function hnp_win_data_get_data(WP_REST_Request $request) {
    $value = get_option('hnp_win_data_value', 'No data set.');
    return new WP_REST_Response($value, 200);
}

// Function to handle POST request
function hnp_win_data_set_data(WP_REST_Request $request) {
    $data = $request->get_body();
    $clean_data = sanitize_text_field($data);
    update_option('hnp_win_data_value', $clean_data);
    return new WP_REST_Response('Data updated successfully.', 200);
}

// Permission check to validate secret key
function hnp_win_data_check_secret_key($request) {
    $headers = $request->get_headers();
    $provided_secret = $headers['x_secret_key'][0] ?? '';
    return $provided_secret === HNP_WIN_DATA_SECRET_KEY;
}

// Shortcode to display the data in the frontend
add_shortcode('hnp_win_data_display', 'hnp_win_data_display_shortcode');
function hnp_win_data_display_shortcode() {
    $value = get_option('hnp_win_data_value', 'No data set.');
    return esc_html($value);
}

Der HNP Win Data Handler ist ein Beispiel für die erfolgreiche Integration von Web- und Desktop-Technologien zur Datensynchronisation. Die Kombination aus einem WordPress-Plugin und einer C#-Anwendung bietet eine sichere und flexible Lösung für das Datenmanagement, die in vielen Geschäftsbereichen und Anwendungen nützlich sein kann. Mit seinem modularen Aufbau und der hohen Sicherheit stellt dieses System eine wertvolle Ressource für Entwickler dar, die in gemischten Technologieumgebungen arbeiten.

Der Beitrag HNP Win Data Handler – Datenaustausch zwischen WordPress & Windows erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Features:

• Frontend und Backend Styling: Das Plugin fügt sowohl dem Frontend als auch dem Backend von WordPress benutzerdefinierte CSS- und JavaScript-Dateien hinzu, um das Erscheinungsbild anzupassen.
• Plugin-Optionen: Es bietet eine einfache Möglichkeit, Plugin-Optionen über das WordPress-Dashboard zu konfigurieren, einschließlich Textfelder, Zahlenfelder, Farbwähler, Dropdown-Listen und Checkboxen.
• Shortcode: Das Plugin stellt einen Shortcode bereit, mit dem Benutzer die konfigurierten Optionen auf beliebigen Seiten oder Beiträgen anzeigen können.
• Sicherheitsmaßnahmen: Das Plugin implementiert Sicherheitsmaßnahmen wie Nonce-Überprüfung, um unerwünschte Zugriffe auf die Plugin-Einstellungen zu verhindern.

Plugin-Download: [sdm_download id=”8187″ fancy=”0″]
Github: https://github.com/HNP-Christopher-Rohde/hnp_empty_wordpress_plugin
Quellcode:

<?php
/*
  Plugin Name: HNP Empty Plugin
  Description: Creates a Demo Plugin in WordPress
  Version: 2.0
  Author: HNP C.R. 
  Author URI: https://homepage-nach-preis.de/
  License: GPLv3
  License URI: https://www.gnu.org/licenses/gpl-3.0.html
 */

// Security check to prevent direct access to the plugin file
defined('ABSPATH') or die('No script kiddies please!');

// Function to enqueue the Frontend CSS and JS
function hnp_empty_plugin_frontend_scripts() {
    // Define a version number
    $version = '2.0';

    // Check if CSS is not already enqueued
    if (!wp_style_is('hnp_empty_plugin_frontend-css')) {
        // Enqueue CSS with the defined version
        wp_enqueue_style('hnp_empty_plugin_frontend-css', plugin_dir_url(__FILE__) . '/frontend/css/hnp_empty_plugin_frontend.css', array(), $version);
    }

    // Check if JavaScript is not already enqueued
    if (!wp_script_is('hnp_empty_plugin_frontend-js')) {
        // Enqueue JavaScript with the defined version
        wp_enqueue_script('hnp_empty_plugin_frontend-js', plugin_dir_url(__FILE__) . '/frontend/js/hnp_empty_plugin_frontend.js', array(), $version, true);
    }
}
add_action('wp_enqueue_scripts', 'hnp_empty_plugin_frontend_scripts');

// Function to enqueue Backend CSS and JS
function hnp_empty_plugin_backend_scripts() {
    // Define a version number
    $version = '2.0';

    // Check if CSS is not already enqueued
    if (!wp_style_is('hnp_empty_plugin_backend-css')) {
        // Enqueue CSS with the defined version
        wp_enqueue_style('hnp_empty_plugin_backend-css', plugin_dir_url(__FILE__) . '/backend/css/hnp_empty_plugin_backend.css', array(), $version);
    }

    // Check if JavaScript is not already enqueued
    if (!wp_script_is('hnp_empty_plugin_backend-js')) {
        // Enqueue JavaScript with the defined version
        wp_enqueue_script('hnp_empty_plugin_backend-js', plugin_dir_url(__FILE__) . '/backend/js/hnp_empty_plugin_backend.js', array(), $version, true);
    }
}
add_action('admin_enqueue_scripts', 'hnp_empty_plugin_backend_scripts');

// Function for Test - with load Options and Fallback
function hnp_empty_plugin_echo_func() {
    // Get option values
    $name = get_option('hnp_empty_plugin_name_field', 'Name');
    $number = get_option('hnp_empty_plugin_number_field', '12');
    $color = get_option('hnp_empty_plugin_color_field', '#ff0000');
    $description = get_option('hnp_empty_plugin_description_field', 'Im a Desc Field');
    $dropdown = get_option('hnp_empty_plugin_dropdown_field', 'option1');
    $checkbox = get_option('hnp_empty_plugin_checkbox_field', 0);

    // Echo option values
    echo '<p>Name Field: ' . esc_html($name) . '</p>';
    echo '<p>Number Field: ' . esc_html($number) . '</p>';
    echo '<p>Color Field: ' . esc_html($color) . '</p>';
    echo '<p>Description Field: ' . esc_html($description) . '</p>';
    echo '<p>Dropdown Field: ' . esc_html($dropdown) . '</p>';
    echo '<p>Checkbox Field: ' . ($checkbox ? 'Enabled' : 'Disabled') . '</p>';
}
add_shortcode('hnp_empty_plugin_echo_func', 'hnp_empty_plugin_echo_func');


// Function to add plugin options to the main menu
function hnp_empty_plugin_add_plugin_options_page() {
    // Check permission
    if (current_user_can('manage_options')) {
        add_menu_page(
            'HNP Empty Plugin Settings',
            'HNP Empty Plugin',
            'manage_options',
            'hnp-empty-plugin-settings',
            'hnp_empty_plugin_render_plugin_options_page',
            plugin_dir_url(__FILE__) . 'img/hnp-favi.png' 
        );
    }
}
add_action('admin_menu', 'hnp_empty_plugin_add_plugin_options_page');


// Function to render plugin options page
function hnp_empty_plugin_render_plugin_options_page() {
    ?>
    <div class="wrap hnp-empty-plugin-settings">
        <h1>HNP Empty Plugin Settings</h1>
        <form method="post" action="options.php">
            <?php settings_fields('hnp_empty_plugin_settings_group'); ?>
            <?php do_settings_sections('hnp-empty-plugin-settings'); ?>
            
            <?php 
                // Add nonce
                wp_nonce_field('hnp_empty_plugin_settings_nonce', 'hnp_empty_plugin_settings_nonce'); 
            ?>
            
            <?php submit_button(); ?>
        </form>
    </div>
    <?php
}

// Function to register plugin options
function hnp_empty_plugin_register_plugin_options() {
    // Name
    add_settings_section(
        'hnp_empty_plugin_name_section',
        'Demo',
        'hnp_empty_plugin_demo_section_callback',
        'hnp-empty-plugin-settings'
    );

    // Name
    add_settings_field(
        'hnp_empty_plugin_name_field', 
        'Name Field', 
        'hnp_empty_plugin_name_field_callback', 
        'hnp-empty-plugin-settings', 
        'hnp_empty_plugin_name_section' 
    );

    // Number
    add_settings_field(
        'hnp_empty_plugin_number_field',
        'Number Field',
        'hnp_empty_plugin_number_field_callback',
        'hnp-empty-plugin-settings',
        'hnp_empty_plugin_name_section'
    );

    // Color
    add_settings_field(
        'hnp_empty_plugin_color_field',
        'Color Field',
        'hnp_empty_plugin_color_field_callback',
        'hnp-empty-plugin-settings',
        'hnp_empty_plugin_name_section'
    );

    // Description
    add_settings_field(
        'hnp_empty_plugin_description_field',
        'Description Field',
        'hnp_empty_plugin_description_field_callback',
        'hnp-empty-plugin-settings',
        'hnp_empty_plugin_name_section'
    );

    // Dropdown
    add_settings_field(
        'hnp_empty_plugin_dropdown_field',
        'Dropdown Field',
        'hnp_empty_plugin_dropdown_field_callback',
        'hnp-empty-plugin-settings',
        'hnp_empty_plugin_name_section'
    );

    // Checkbox
    add_settings_field(
        'hnp_empty_plugin_checkbox_field',
        'Checkbox Field',
        'hnp_empty_plugin_checkbox_field_callback',
        'hnp-empty-plugin-settings',
        'hnp_empty_plugin_name_section'
    );
}
add_action('admin_init', 'hnp_empty_plugin_register_plugin_options');

// Callback function for demo section
function hnp_empty_plugin_demo_section_callback() {
    echo 'This a Demo Plugin. Frontend-Shortcode: &#x5B;hnp_empty_plugin_echo_func]</p>';
}

// Callback function for name field
function hnp_empty_plugin_name_field_callback() {
    $value = get_option('hnp_empty_plugin_name_field', 'Name'); // Fallback value is 'Name'
    echo '<input type="text" name="hnp_empty_plugin_name_field" value="' . esc_attr($value) . '" />';
}

// Callback functions for number fields
function hnp_empty_plugin_number_field_callback() {
    $value = get_option('hnp_empty_plugin_number_field', '12'); // Fallback value is '12'
    echo '<input type="number" name="hnp_empty_plugin_number_field" value="' . esc_attr($value) . '" />';
}

// Callback function for Color Field
function hnp_empty_plugin_color_field_callback() {
    $value = get_option('hnp_empty_plugin_color_field', '#ff0000'); // Fallback value is red color
    echo '<input type="color" name="hnp_empty_plugin_color_field" value="' . esc_attr($value) . '" />';
}

// Callback function for Description Field
function hnp_empty_plugin_description_field_callback() {
    $value = get_option('hnp_empty_plugin_description_field', 'Im a Desc Field'); // Fallback value is 'Im a Desc Field'
    echo '<textarea name="hnp_empty_plugin_description_field">' . esc_html($value) . '</textarea>';
}

// Callback function for dropdown field
function hnp_empty_plugin_dropdown_field_callback() {
    $value = get_option('hnp_empty_plugin_dropdown_field', 'option1'); // Fallback value is 'option1'
    ?>
    <select name="hnp_empty_plugin_dropdown_field">
        <option value="option1" <?php selected($value, 'option1'); ?>>Option 1</option>
        <option value="option2" <?php selected($value, 'option2'); ?>>Option 2</option>
        <option value="option3" <?php selected($value, 'option3'); ?>>Option 3</option>
    </select>
    <?php
}

// Callback function for checkbox field
function hnp_empty_plugin_checkbox_field_callback() {
    $value = get_option('hnp_empty_plugin_checkbox_field', 0); // Fallback value is 0 (not checked)
    ?>
    <label for="hnp_empty_plugin_checkbox_field">
        <input type="checkbox" name="hnp_empty_plugin_checkbox_field" id="hnp_empty_plugin_checkbox_field" value="1" <?php checked($value, 1); ?>>
        Enable Checkbox
    </label>
    <?php
}

// Security measures: Nonce verification and save options
function hnp_empty_plugin_register_security_options() {
    // Check if the current page is our plugin options page
    if (isset($_POST['option_page']) && $_POST['option_page'] == 'hnp_empty_plugin_settings_group') {
        // Check if the nonce is set and valid
        if (!isset($_POST['hnp_empty_plugin_settings_nonce']) || !wp_verify_nonce($_POST['hnp_empty_plugin_settings_nonce'], 'hnp_empty_plugin_settings_nonce')) {
            // Unauthorized request, do not save options
            wp_die('Unauthorized request.'); // Output error message for unauthorized requests
        }

        // Save options
        update_option('hnp_empty_plugin_name_field', $_POST['hnp_empty_plugin_name_field']);
        update_option('hnp_empty_plugin_number_field', sanitize_text_field($_POST['hnp_empty_plugin_number_field']));
        update_option('hnp_empty_plugin_color_field', sanitize_text_field($_POST['hnp_empty_plugin_color_field']));
        update_option('hnp_empty_plugin_description_field', sanitize_textarea_field($_POST['hnp_empty_plugin_description_field']));
        update_option('hnp_empty_plugin_dropdown_field', sanitize_text_field($_POST['hnp_empty_plugin_dropdown_field']));
        update_option('hnp_empty_plugin_checkbox_field', isset($_POST['hnp_empty_plugin_checkbox_field']) ? 1 : 0);
    }
}
add_action('admin_init', 'hnp_empty_plugin_register_security_options');

// Register plugin options and security measures
function hnp_empty_plugin_register_settings() {
    // Register setting and sanitize callback
    register_setting('hnp_empty_plugin_settings_group', 'hnp_empty_plugin_name_field');
    register_setting('hnp_empty_plugin_settings_group', 'hnp_empty_plugin_number_field');
    register_setting('hnp_empty_plugin_settings_group', 'hnp_empty_plugin_color_field');
    register_setting('hnp_empty_plugin_settings_group', 'hnp_empty_plugin_description_field');
    register_setting('hnp_empty_plugin_settings_group', 'hnp_empty_plugin_dropdown_field');
    register_setting('hnp_empty_plugin_settings_group', 'hnp_empty_plugin_checkbox_field');
}
add_action('admin_init', 'hnp_empty_plugin_register_settings');


// Security measures: Nonce verification for options update
function hnp_empty_plugin_validate_settings($input) {
    return $input; // Simply return the input, no further validation here
}

Der Beitrag HNP Empty Plugin – WordPress Demo Code erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Die grundlegende Arbeitsweise von AJAX besteht darin, dass der Browser mithilfe von JavaScript eine HTTP-Anfrage an den Server sendet. Der Server verarbeitet dann die Anfrage und sendet eine Antwort zurück, die vom JavaScript-Code auf der Client-Seite verarbeitet wird.

In der Regel werden AJAX-Anfragen verwendet, um Daten im Hintergrund zu laden, Benutzeraktionen zu verarbeiten oder mit einem Server zu kommunizieren, ohne dass die Seite neu geladen werden muss. Dies kann beispielsweise bei der Validierung von Formularen, dem Laden von zusätzlichen Inhalten oder der Aktualisierung von Benutzerdaten nützlich sein.

Um AJAX in einer Webseite zu implementieren, wird normalerweise JavaScript verwendet, um die Anfrage zu senden, und auf der Serverseite wird die Anfrage mit einer Programmiersprache wie PHP oder Python verarbeitet.

In WordPress wird AJAX häufig verwendet, um dynamische Inhalte in Themes und Plugins zu laden, ohne die Seite neu zu laden. WordPress bietet spezielle Funktionen und Hooks für die Verarbeitung von AJAX-Anfragen, was die Implementierung erleichtert. Hierzu ein praktisches Beispiel:
WordPress:
Javascript:

document.addEventListener("DOMContentLoaded", function() {
    var hnpAjaxButton = document.getElementById("hnp_ajax_button");
    
    hnpAjaxButton.addEventListener("click", function() {
        var xhr = new XMLHttpRequest();
        xhr.open("POST", ajax_object.ajax_url, true);
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
        xhr.onreadystatechange = function() {
            if (xhr.readyState === 4 && xhr.status === 200) {
                alert("Server sagt: " + xhr.responseText);
            }
        };
        xhr.send("action=hnp_ajax_funktion");
    });
});

PHP

add_action('wp_enqueue_scripts', 'hnp_ajax_scripts');
function hnp_ajax_scripts() {
    wp_enqueue_script('hnp-ajax-script', get_stylesheet_directory_uri() . '/js/hnp-ajax-script.js', array(), '1.0', true);
    wp_localize_script('hnp-ajax-script', 'ajax_object', array('ajax_url' => admin_url('admin-ajax.php')));
}

add_action('wp_ajax_hnp_ajax_funktion', 'meine_ajax_callback');
add_action('wp_ajax_nopriv_hnp_ajax_funktion', 'meine_ajax_callback');
function meine_ajax_callback() {
    echo 'Hallo von AJAX!';
    die();
}

HTML:

<button id="hnp_ajax_button">Klick mich für eine Begrüßungsnachricht!</button>

ODER Universal:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>AJAX Beispiel</title>
</head>
<body>
    <button id="hnp_ajax_button">Klick mich für eine Begrüßungsnachricht!</button>

    <script>
        document.addEventListener("DOMContentLoaded", function() {
            var hnpAjaxButton = document.getElementById("hnp_ajax_button");
            
            hnpAjaxButton.addEventListener("click", function() {
                var xhr = new XMLHttpRequest();
                xhr.open("POST", "server.php", true); // Hier "server.php" durch die URL des Servers ersetzen, der die AJAX-Anfrage verarbeitet
                xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
                xhr.onreadystatechange = function() {
                    if (xhr.readyState === 4 && xhr.status === 200) {
                        alert("Server sagt: " + xhr.responseText);
                    }
                };
                xhr.send("action=hnp_ajax_funktion");
            });
        });
    </script>
</body>
</html>

Der Beitrag Ajax und WP-Ajax verstehen – Code Beispiel erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

; @Homepage-nach-Preis
; Simple machine language example for detecting and blocking targeted malware file.
; https://homepage-nach-preis.de/
; Written for x86

section .data
    signature db "malware-script.php", 0
    block_message db "Suspicious traffic detected. Connection blocked.", 0

section .text
    global _start

_start:
    ; Create socket
    ; ...

    ; Bind socket
    ; ...

    ; Monitor network traffic
    listen_loop:
        ; Receive packet
        ; ...

        ; Check packet content
        b9 packet_content
        be signature
        31 c9
        f3 a6

        ; Compare
        74 12

        jmp listen_loop

suspicious_traffic:
    ; Suspicious network traffic detected
    ; Block connection
    ; ...

    ; Display block message
    b8 4
    bb 1
    b9 block_message
    ba message_length
    cd 80

    ; Terminate program
    b8 1
    31 db
    cd 80

section .data
    block_message db "Suspicious traffic detected. Connection blocked.", 0
    message_length equ $ - block_message

Der Beitrag hnp Simple Malware Network Block BIN erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

/*
* Name: HNP Simple Port Scan Firewall
* Description: Detect port scans and automatically block attackers.
* Author: Homepage-nach-Preis 
* Version: 1.0
* Author URI: https://homepage-nach-preis.de/
* License: Creative Commons Non-Commercial - CC-NC 4.0
*/

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Diagnostics;

class Hnp_PortScanner
{
    static void Main()
    {
        List<int> hnp_targetPorts = new List<int> { 12345, 80, 443 }; // List of target ports or port range to monitor
        int hnp_emptyPacketThreshold = 5; // Number of empty packets before the IP address is blocked
        int hnp_synPacketThreshold = 10; // Number of SYN packets before the IP address is blocked

        Dictionary<IPAddress, int> hnp_emptyPackets = new Dictionary<IPAddress, int>();
        Dictionary<IPAddress, int> hnp_synPackets = new Dictionary<IPAddress, int>();

        using (UdpClient hnp_udpClient = new UdpClient())
        using (TcpListener hnp_tcpListener = new TcpListener(IPAddress.Any, hnp_targetPorts[0]))
        {
            hnp_tcpListener.Start();

            Console.WriteLine("Port Scanner is listening...");

            while (true)
            {
                try
                {
                    // Monitoring UDP packets
                    IPEndPoint hnp_udpSenderEndPoint = new IPEndPoint(IPAddress.Any, 0);
                    byte[] hnp_udpReceivedBytes = hnp_udpClient.Receive(ref hnp_udpSenderEndPoint);

                    if (hnp_targetPorts.Contains(hnp_udpSenderEndPoint.Port) && hnp_udpReceivedBytes.Length == 0)
                    {
                        if (!hnp_emptyPackets.ContainsKey(hnp_udpSenderEndPoint.Address))
                            hnp_emptyPackets[hnp_udpSenderEndPoint.Address] = 0;

                        hnp_emptyPackets[hnp_udpSenderEndPoint.Address]++;

                        Console.WriteLine($"Empty UDP packet received from {hnp_udpSenderEndPoint.Address}:{hnp_udpSenderEndPoint.Port}. Possible port scan attempt.");

                        if (hnp_emptyPackets[hnp_udpSenderEndPoint.Address] >= hnp_emptyPacketThreshold)
                        {
                            Hnp_BlockIpAddress(hnp_udpSenderEndPoint.Address);
                            Console.WriteLine($"IP address {hnp_udpSenderEndPoint.Address} has been blocked.");
                            hnp_emptyPackets.Remove(hnp_udpSenderEndPoint.Address);
                        }
                    }

                    // Monitoring TCP-SYN packets
                    TcpClient hnp_tcpClient = hnp_tcpListener.AcceptTcpClient();
                    IPEndPoint hnp_tcpSenderEndPoint = (IPEndPoint)hnp_tcpClient.Client.RemoteEndPoint;

                    if (hnp_targetPorts.Contains(hnp_tcpSenderEndPoint.Port))
                    {
                        if (!hnp_synPackets.ContainsKey(hnp_tcpSenderEndPoint.Address))
                            hnp_synPackets[hnp_tcpSenderEndPoint.Address] = 0;

                        hnp_synPackets[hnp_tcpSenderEndPoint.Address]++;

                        Console.WriteLine($"TCP-SYN packet received from {hnp_tcpSenderEndPoint.Address}:{hnp_tcpSenderEndPoint.Port}. Possible port scan attempt.");

                        if (hnp_synPackets[hnp_tcpSenderEndPoint.Address] >= hnp_synPacketThreshold)
                        {
                            Hnp_BlockIpAddress(hnp_tcpSenderEndPoint.Address);
                            Console.WriteLine($"IP address {hnp_tcpSenderEndPoint.Address} has been blocked.");
                            hnp_synPackets.Remove(hnp_tcpSenderEndPoint.Address);
                        }
                    }

                    hnp_tcpClient.Close();
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error occurred: {ex.Message}");
                }
            }
        }
    }

    static void Hnp_BlockIpAddress(IPAddress hnp_ipAddress)
    {
        string hnp_arguments = $"advfirewall firewall add rule name=\"Block IP\" dir=in interface=any action=block remoteip={hnp_ipAddress}";
        Process.Start("netsh", hnp_arguments)?.WaitForExit();
    }
}

Der Beitrag HNP Simple Port Scan Firewall C# erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

WordPress Version entfernen

Entfernen der WordPress-Version im Header

function hnp_remove_version_info() {
	return '';
}
add_filter( 'the_generator', 'hnp_remove_version_info' );

WordPress Emoji entfernen

WordPress Emoji dauerhaft entfernen

function hnp_wp_emojicons() {
	remove_action( 'admin_print_styles', 'print_emoji_styles' );
	remove_action( 'wp_head', 'print_emoji_detection_script', 7 );
	remove_action( 'admin_print_scripts', 'print_emoji_detection_script' );
	remove_action( 'wp_print_styles', 'print_emoji_styles' );
	remove_filter( 'wp_mail', 'wp_staticize_emoji_for_email' );
	remove_filter( 'the_content_feed', 'wp_staticize_emoji' );
	remove_filter( 'comment_text_rss', 'wp_staticize_emoji' );
	add_filter( 'tiny_mce_plugins', 'hnp_emojicons_tinymce' );
	add_filter( 'emoji_svg_url', '__return_false' );
}
add_action( 'init', 'hnp_wp_emojicons' );
function hnp_emojicons_tinymce( $plugins ) {
	if ( is_array( $plugins ) ) {
		return array_diff( $plugins, array( 'wpemoji' ) );
	} else {
		return array();
	}
}

Beiträge entfernen

Beiträge Funktion deaktivieren

add_action( 'init', 'hnp_remove_default_post_type', 1 );
function hnp_remove_default_post_type() {
	register_post_type( 'post', array(
		'capability_type' => 'post',
		'capabilities' => array(
			'edit_post' => 'do_not_allow', // false < WP 4.5
			'publish_posts' => 'do_not_allow', // false < WP 4.5
			'create_posts' => 'do_not_allow', // false < WP 4.5
			'edit_posts' => 'do_not_allow', // false < WP 4.5
		),
		'map_meta_cap' => false
	) );
}

Kommentar Funktion entfernen

Kommentare deaktivieren

// Admin Menu
add_action( 'admin_menu', 'hnp_remove_admin_menus' );
function hnp_remove_admin_menus() {
	remove_menu_page( 'edit-comments.php' );
}
// Seiten und Beiträge
add_action( 'init', 'remove_comment_support', 100 );
function remove_comment_support() {
	remove_post_type_support( 'post', 'comments' );
	remove_post_type_support( 'page', 'comments' );
}
// Admin Leiste
function hnp_admin_bar_render() {
	global $wp_admin_bar;
	$wp_admin_bar->remove_menu( 'comments' );
}
add_action( 'wp_before_admin_bar_render', 'hnp_admin_bar_render' );

Der Beitrag Die besten WordPress Codes – Teil 1 erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

Viele User können nach dem WordPress Update zu Version 5.5 / 5.6 ihre Webseite nicht mehr nutzen. Das liegt an der jQuery Änderung zu einer neueren Version. Die alten Befehle werden somit nicht mehr übernommen und es erzeugt Fehler. Die meisten veralteten Befehle können aber sehr einfach geupdatet werden. Hierbei die wichtigsten Änderungen mit Fehlermeldungen:

Fehlercodes mit Lösung

JQMIGRATE: jQuery.fn.delegate() is deprecated
JQMIGRATE: jQuery.fn.undelegate() is deprecated
JQMIGRATE: jQuery.fn.bind() is deprecated
JQMIGRATE: jQuery.fn.unbind() is deprecated
Lösung: .bind () und .unbind () direkt in .on () bzw. .off () umbenennen.

JQMIGRATE: ‘ready’ event is deprecated
Lösung: $( document ).on( "ready", fn ) mit der direkten Funktion $( fn ) austauschen.

JQMIGRATE: jQuery.fn.unload() is deprecated
JQMIGRATE: jQuery.fn.load() is deprecated
Lösung: $().load(fn) ändern zu $().on("load", fn) und $().unload(fn) zu $().on("unload", fn).

JQMIGRATE: jQuery.fn.error() is deprecated
Lösung: $().error(fn) ändern zu $().on("error", fn).

JQMIGRATE: jQXHR.success is deprecated and removed
JQMIGRATE: jQXHR.error is deprecated and removed
JQMIGRATE: jQXHR.complete is deprecated and removed
Lösung: .success() ändern zu .done(), .error() ändern zu .fail(), und .complete() zu .always().

JQMIGRATE: deferred.pipe() is deprecated
Lösung: Änderung von .pipe() zu .then()

JQMIGRATE: jQuery.fn.andSelf() is deprecated and removed
Lösung: .andSelf() mit .addBack() austauschen.

JQMIGRATE: jQuery.fn.size() is deprecated and removed
Lösung: Austauschen von .size() mit .length.

jQuery.fn.offset() requires a valid DOM element
Lösung: Die Offset-Informationen nicht mit einer ungültigen Eingabe(Input) festlegen.

JQMIGRATE: ‘jQuery.easing.NAME’ should use only one argument
Lösung:
jQuery.easing.easeInCubic = function ( p, t, b, c, d ) {
return c * ( t /= d ) * t * t + b;
}
ändern zu
jQuery.easing.easeInCubic = function ( p ) {
return Math.pow( p, 3 );
}

JQMIGRATE: jQuery.parseJSON is deprecated
Lösung: jQuery.parseJSON ändern zu JSON.parse.

JQMIGRATE: jQuery.unique is deprecated
Lösung: jQuery.unique ändern zu jQuery.uniqueSort.

JQMIGRATE: jQuery.expr.filters is deprecated
Lösung: jQuery.expr.filters ändern zu jQuery.expr.pseudos.

JQMIGRATE: jQuery.fn.click() event shorthand is deprecated
Lösung: .click(fn) ändern zu .on("click", fn). Und .click() zu .trigger("click")

JQMIGRATE: jQuery.fn.hover() is deprecated
Lösung: .hover(fn1, fn2)ändern zu .on("mouseenter", fn1).on("mouseleave", fn2).

jQuery.cssProps is deprecated
Lösung: Entfernung aller jQuery.cssProps im Code.

jQuery.isArray is deprecated
Lösung: Austauschen von jQuery.isArray mit Array.isArray.

jQuery.trim is deprecated; use String.prototype.trim
Lösung: Austauschen von jQuery.trim( text ) mit text.trim() (Wenn der Text ein String ist)
Ansonsten mit String.prototype.trim.call( text == null ? "" : text ).

Der Beitrag WordPress 5.5 & 5.6 jQuery Fehler-Lösungen erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.

1. Kopieren Sie den Code
2. Tauschen Sie Folgendes aus:
(“Gebühr” ist der Name der Gebühr, Sie können hierbei auch “Bearbeitungskosten” oder sonstiges eintragen – “99” ist der Betrag in Ihrer eingestellten Währung, also in dem Fall somit 99 Euro)
3. Fügen Sie den Code in Ihre function.php im Hauptverzeichnis ein
4. Speichern und fertig

function woo_add_cart_fee() {
 global $woocommerce;
   $woocommerce->cart->add_fee( __('Gebühr', 'woocommerce'), 99 );
}
add_action( 'woocommerce_cart_calculate_fees', 'woo_add_cart_fee' );

Möchten Sie einen professionellen Onlineshop erstellen lassen? FESTPREIS ANGEBOTE

Der Beitrag Woocommerce feste Warenkorb-Gebühr erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Christopher Rohde.

Jeder Blog-Besitzer kennt sie, die unendlichen Spam-Einträge in Blog-Kommentaren. Woher kommen diese aber, wer schreibt solche Spam-Kommentare und wieso? Natürlich werden die Spam-Einträge meist nicht per Hand geschrieben, sondern von Spam-Bots automatisch erstellt. Der Hauptgrund der Einträge ist Backlink-Building, also um Links von anderen Webseiten zu erhalten und in schnellster Zeit relevant für Suchmaschinen zu werden. Ebenso soll Traffic (Besucher) für die kuriosen Spam-Betreiber-Webseiten erzeugt werden.

Steigt das Ranking dadurch?

Kurzzeitig ja, je nach Anzahl der umgesetzten Spam-Kommentare werden aber solche Webseiten früher oder später aus dem Ranking der Suchmaschinen genommen und mit einer dauerhaften “Penetration” bestraft. Für die Spam-Betreiber ist das aber nicht weiter schlimm, denn Sie besitzen hunderte solcher Webseiten und wenn halt eine Seite bestraft wurde, so wird diese einfach abgeworfen und eine neue per Fertig-Template erstellt.

Vor Spam Bots schützen

Es gibt einige Möglichkeiten um Spam-Bots zu erkennen und von einer Webseite auszuschließen, ich empfehle hierbei eine “Honey Pot” Funktion. Honey Pot heißt im deutschen Honigtopf und soll Bots anlocken um diese zu erkennen. In der Umsetzung wird beispielsweise ein verstecktes Fenster im Blog programmiert, welches von einer organischen Person nicht gesehen werden kann, da es nur im Quellcode existiert. Ein Bot hingegen sieht eine Webseite nicht gerendert, sondern nur den Quellcodes und somit auch die “Input” Tabellen. Eine versteckte Tabelle wird nur von einem Bot ausgefüllt und der Übeltäter lässt sich dadurch identifizieren.

Honey-Pot WordPress Plugin

Für WordPress muss eine solche Funktion nicht selbst geschrieben/programmiert werden. Einfach eins der vielen “Honeypot”-Plugins aus der WordPress Sammlung installieren.

Honey-Pot Php Code

Wer selbst einen Schutz einbinden möchte, kann dies über ein kleines Php-Script:

function preprocess_new_comment($commentdata)
{
if(!isset($_POST['is_legit']))
{ die('Waidmannsheil Spambot, aber nicht hier!'); }
return $commentdata;
}
if(function_exists('add_action'))
{add_action('preprocess_comment', 'preprocess_new_comment');
}

Natürlich würde auch eine Captcha-Funktion die meisten Spam-Bots blockieren, allerdings verringert dies ebenso die Aktivitäten von Besuchern und ist somit nicht die beste Lösung.

Wir bieten Webseiten Optimierungen ab bereits 149 Euro. MEHR INFOS

Der Beitrag Webseite vor Spam-Bots schützen erschien zuerst auf Homepage nach Preis - Webseite erstellen lassen. Geschrieben von Homepage-nach-Preis.