Wie kann ich eine Bitmaske auf / dev / zero setzen, damit ich andere Bytes als Null erhalten kann?

Wie kann ich eine Bitmaske /dev/zeroaufsetzen, damit ich eine Quelle nicht nur für 0x00, sondern auch für ein beliebiges Byte zwischen 0x01 und 0xFF haben kann?

Der folgende bashCode ist so eingestellt, dass er mit dem Byte arbeitet, das in der Binärdatei wiedergegeben wird . Allerdings können Sie es leicht zu handhaben ändern ocatal , dezimal oder hex einfach durch den Wechsel radix r Wert 2 zu 8, 10oder 16jeweils und Einstellung b=entsprechend.

r=2; b=01111110
printf -vo '\\%o' "$(($r#$b))"; </dev/zero tr '\0' "$o"

BEARBEITEN - Es wird der gesamte Bereich der Bytewerte verarbeitet: hex 00 - FF (als ich 00-7F unten schrieb, habe ich nur Einzelbyte-UTF-8-Zeichen in Betracht gezogen).

Wenn Sie zum Beispiel nur 4 Bytes (Zeichen im UTF-8-Bereich 'ASCII'-only hex 00-7F) möchten , können Sie dies in head umleiten :... | head -c4

Ausgabe (4 Zeichen):

~~~~

Um die Ausgabe im 8-Bit-Format anzuzeigen, leiten Sie sie weiter in xxd(oder einen anderen Byte-Dump * von 1 und 0 ):
z. b=10000000und Rohrleitungen zu:... | head -c4 | xxd -b

0000000: 10000000 10000000 10000000 10000000                    ....

Das kann man nicht so einfach machen.

Sie können ein eigenes Kernelmodul schreiben, das ein solches Gerät bereitstellt. Das empfehle ich nicht.

Sie könnten ein winziges C-Programm schreiben, das einen unendlichen Strom gleicher Bytes auf eine Pipe (oder auf stdout) oder ein FIFO schreibt .

Sie könnten tr (1) verwenden , um aus /dev/zerojedem 0-Byte etwas anderes zu lesen und es zu übersetzen.

Sie könnten vielleicht yes (1) verwenden , zumindest wenn Sie es sich leisten können, Zeilenumbrüche zu haben (oder es weiterzuleiten tr -d '\n'...)

Wenn Sie dies im wahrsten Sinne des Wortes erreichen möchten, können Sie einen LD_PRELOAD-Hook verwenden . Die Grundidee ist, eine Funktion aus der C-Bibliothek neu zu schreiben und anstelle der normalen zu verwenden.

Hier ist ein einfaches Beispiel, in dem wir die Funktion read () überschreiben, um den Ausgabepuffer mit 0x42 zu XOR zu verknüpfen.

#define _GNU_SOURCE
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <dlfcn.h> 
#include <unistd.h>

static int dev_zero_fd = -1;

int open64(const char *pathname, int flags)
{
    static int (*true_open64)(const char*, int) = NULL;
    if (true_open64 == NULL) {
        if ((true_open64 = dlsym(RTLD_NEXT, "open64")) == NULL) {
            perror("dlsym");
            return -1;
        }        
    }
    int ret = true_open64(pathname, flags);
    if (strcmp(pathname, "/dev/zero") == 0) {
        dev_zero_fd = ret;
    }
    return ret;
}


ssize_t read(int fd, void *buf, size_t count)
{
    static ssize_t (*true_read)(int, void*, size_t) = NULL;
    if (true_read == NULL) {
        if ((true_read = dlsym(RTLD_NEXT, "read")) == NULL) {
            perror("dlsym");
            return -1;
        }        
    }    

    if (fd == dev_zero_fd) {
        int i;
        ssize_t ret = true_read(fd, buf, count);    
        for (i = 0; i < ret; i++) {
            *((char*)buf + i) ^= 0x42;
        }
        return ret;
    }

    return true_read(fd, buf, count);    
}

Eine naive Implementierung würde XOR 0x42 für jede gelesene Datei bedeuten, was unerwünschte Konsequenzen hätte. Um dieses Problem zu lösen, habe ich auch die open () - Funktion eingebunden, sodass sie den Dateideskriptor abruft, der mit / dev / zero verknüpft ist. Dann führen wir das XOR in unserer read () - Funktion nur aus, wenn fd == dev_zero_fd.

Verwendung:

$ gcc hook.c -ldl -shared -o hook.so
$ LD_PRELOAD=$(pwd)/hook.so bash #this spawns a hooked shell
$ cat /dev/zero
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB

In Bezug auf die Geschwindigkeit war die schnellste, die ich gefunden habe:

$ PERLIO=:unix perl -e '$s="\1" x 65536; for(;;){print $s}' | pv -a > /dev/null
[4.02GiB/s]

Zum Vergleich:

$ tr '\0' '\1' < /dev/zero | pv -a > /dev/null
[ 765MiB/s]
$ busybox tr '\0' '\1' < /dev/zero | pv -a > /dev/null
[ 399MiB/s]

$ yes $'\1' | tr -d '\n' | pv -a > /dev/null
[26.7MiB/s]

$ dash -c 'while:; do echo -n "\ 1"; erledigt '| pv -a> / dev / null
[225 KB / s]

$ bash -c 'while:; do echo -ne "\ 1"; erledigt '| pv -a> / dev / null
[180 KB / s]

$ < /dev/zero pv -a > /dev/null
[5.56GiB/s]
$ cat /dev/zero | pv -a > /dev/null
[2.82GiB/s]

Es ist irgendwie sinnlos zu versuchen, eine Bitmaske / x oder null Bytes zu erstellen, nicht wahr? Ein Byte zu nehmen und xormit Null zu belegen, ist ein No-Op.

Erstellen Sie einfach eine Schleife, die die gewünschten Bytes enthält, und setzen Sie sie hinter eine Pipe oder Named Pipe. Es verhält sich so ziemlich wie ein Zeichengerät (verschwendet im Leerlauf keine CPU-Zyklen):

mkfifo pipe
while : ; do echo -n "a"; done > pipe &

Und wenn Sie es optimieren möchten, können Sie den folgenden C-Code verwenden:

#include <stdio.h>
#include <string.h>

int main(int argc, char **argv) { 
  char c = argc == 1+1 ? argv[1][0] : 'y';

  char buff[BUFSIZ];
  memset(buff, c, BUFSIZ);

  for(;;){ 
    write(1, buff, sizeof(buff)); 
  }
}

kompilieren & ausführen

$ CFLAGS=-O3 make loop
./loop "$the_byte_you_want" > pipe

Leistungstest:

./loop 1 | pv -a >/dev/null 

2,1 GB / s auf meinem Computer (sogar etwas schneller als cat /dev/zero | pv -a >/dev/null)

Lesen Sie Nullen, übersetzen Sie jede Null in Ihr Muster!

Wir lesen Null-Bytes aus /dev/zeround trwenden eine Bitmaske auf jedes der Bytes an, indem wir jedes Null-Byte übersetzen:

$ </dev/zero tr '\000' '\176' | head -c 10
~~~~~~~~~~$

Oktal 176 ist der ASCII-Code von ~, also erhalten wir 10 ~. (Das $am Ende der Ausgabe zeigt in meiner Shell an, dass es kein Zeilenende gab - es könnte für Sie anders aussehen)

Lassen Sie uns also 0xFFBytes erstellen : Hex 0xFFist oktal 0377. Die führende Null wird in der trBefehlszeile weggelassen. Am Ende hexdumpwird verwendet, um die Ausgabe lesbar zu machen.

$ </dev/zero tr '\000' '\377' | head -c 10 | hexdump
0000000 ffff ffff ffff ffff ffff               
000000a

Sie müssen hier die Oktalcodes der Zeichen anstelle des Hexadezimals verwenden. Es ist also der Bereich von \000bis oktal \377(genauso wie 0xFF).
Verwenden Sie ascii -xund ascii -o, um eine Tabelle der Zeichen mit hexadezimalen oder oktalen Indexnummern zu erhalten.
(Für eine Tabelle mit Dezimal- und Hexadezimalzahl nur ascii).

Ziemlich schnell

Es läuft ziemlich schnell, verglichen mit der Verwendung von Nullen: Es cat /dev/zeroist nur viermal so schnell, während es die E / A-Pufferung perfekt nutzen trkann , was nicht möglich ist.

$ </dev/zero tr '\000' '\176' | pv -a >/dev/null
[ 913MB/s]

$ </dev/zero cat | pv -a >/dev/null        
[4.37GB/s]

Hängt davon ab, was Sie mit den Daten machen möchten und wie flexibel Sie sie verwenden möchten.

Im schlimmsten Fall, wenn Sie Geschwindigkeit benötigen, können Sie das Gleiche wie mit / dev / zero tun und einfach die Geräte / dev / one, / dev / two, ... / dev / fourtytwo ... und so weiter kompilieren.

In den meisten Fällen ist es besser, die Daten direkt dort zu erstellen, wo sie benötigt werden, also innerhalb eines Programms / Skripts als Konstante. Mit mehr Informationen könnten Ihnen die Leute besser helfen.

Endlosschleife

Ersetzen Sie \u00mit dem gewünschten Byte.

while true ; do printf "\u00" ; done | yourapp

C ++ Code:

#include<cstdio>

int main(){
 char out=Byte;
 while(true)
 fwrite(&out,sizeof(out),1,stdout);
}

Kompilieren: Ersetzen Sie Bytemit dem gewünschten Wert.

g++ -O3 -o bin file.cpp -D Byte=0x01

Verwenden

./bin | yourapp